Introduction to Perl

1. Introduction to Perl Dave Cross Magnum Solutions Ltd [email_address]

2. What We Will Cover What is Perl?

3. Creating and running a Perl program

4. Getting help

5. Input and Output

6. Perl variables

7. Operators and Functions

8. What We Will Cover Conditional Constructs

9. Subroutines

10. Regular Expressions

11. Smart Matching

12. Finding and using Modules

13. Schedule 09:45 – Begin

14. 11:15 – Coffee break (15 mins)

15. 13:00 – Lunch (60 mins)

16. 14:00 – Begin

17. 15:30 – Coffee break (15 mins)

18. 17:00 – End

19. Resources Slides available on-line http://mag-sol.com/train/public/2009-11/ukuug Also see Slideshare http://www.slideshare.net/davorg/slideshows Get Satisfaction http://getsatisfaction.com/magnum

20. What is Perl?

21. Perl's Name Practical Extraction and Reporting Language

22. Pathologically Eclectic Rubbish Lister

23. “Perl” is the language

24. “perl” is the compiler

25. Never “PERL”

26. Typical Uses of Perl Text processing

27. System administration tasks

28. CGI and web programming

29. Database interaction

30. Other Internet programming

31. Less Typical Uses of Perl Human Genome Project

32. NASA

33. What is Perl Like? General purpose programming language

34. Free (open source)‏

35. Fast

36. Flexible

37. Secure

38. Fun

39. The Perl Philosophy There's more than one way to do it

40. Three virtues of a programmer Laziness

41. Impatience

42. Hubris Share and enjoy!

43. Creating and Running a Perl Program

44. Creating a Perl Program Our first Perl program

45. print "Hello world\n";

46. Put this in a file called hello.pl

47. Running a Perl Program Running a Perl program from the command line

48. $ perl hello.pl

49. Running a Perl Program The "shebang" line (Unix, not Perl)

50. #!/usr/bin/perl

51. Make program executable

52. $ chmod +x hello.pl

53. Run from command line

54. $ ./hello.pl

55. Perl Comments Add comments to your code

56. Start with a hash (#)‏

57. Continue to end of line

58. # This is a hello world program print "Hello, world!\n"; # print

59. Command Line Options Options to control execution of the program

60. For example, -w turns on warnings

61. Use on command line

62. perl -w hello.pl

63. Or on shebang line

64. #!/usr/bin/perl -w

65. More usually use warnings

66. Getting Help

67. Perl Documentation Perl comes with a huge amount of documentation

68. Accessed through the perldoc command

69. perldoc perl

70. perldoc perltoc – table of contents

71. Also online at http://perldoc.perl.org/

72. Lots of references through the course

73. Some Useful Pages perlintro

74. perldata

75. perlsyn

76. perlfaq

77. perlstyle

78. perlcheat

79. Many many more

80. Perl Variables

81. What is a Variable? A place where we can store data

82. A variable needs a name To put new data in it

83. To retrieve the data stored in it

84. Variable Names Contain alphanumeric characters and underscores

85. User variable names may not start with numbers

86. Variable names are preceded by a punctuation mark indicating the type of data

87. Types of Perl Variable Different types of variables start with a different symbol Scalar variables start with $

88. Array variables start with @

89. Hash variables start with % More on these types soon

90. Declaring Variables You don't need to declare variables in Perl

91. But it's a very good idea typos

92. scoping Using the strict pragma

93. use strict; my $var;

94. Scalar Variables Store a single item of data

95. my $name = "Arthur";

96. my $whoami = 'Just Another Perl Hacker';

97. my $meaning_of_life = 42;

98. my $number_less_than_1 = 0.000001;

99. my $very_large_number = 3.27e17; # 3.27 times 10 to the power of 17

100. Type Conversions Perl converts between strings and numbers whenever necessary

101. Add int to a floating point number

102. my $sum = $meaning_of_life + $number_less_than_1;

103. Putting a number into a string

104. print "$name says, 'The meaning of life is $sum.'\n";

105. Quoting Strings Single quotes don't expand variables or escape sequences

106. my $price = '$9.95';

107. Double quotes do

108. my $invline = "24 widgets @ $price each\n";

109. Backslashes Use a backslash to escape special characters in double quoted strings

110. print "He said \"The price is \$300\"";

111. This can look ugly

112. Better Quotes This is a tidier alternative

113. print qq(He said "The price is \$300");

114. Also works for single quotes

115. print q(He said "That's too expensive");

116. Undefined Values A scalar variable that hasn't had data put into it will contain the special value “undef”

117. Test for it with defined() function

118. if (defined($my_var)) { ... }

119. Array Variables Arrays contain an ordered list of scalar values

120. my @fruit = ('apples', 'oranges', 'guavas', 'passionfruit', 'grapes');

121. my @magic_numbers = (23, 42, 69);

122. my @random_scalars = ('mumble', 123.45, 'dave cross', -300, $name);

123. Array Elements Accessing individual elements of an array

124. print $fruits[0]; # prints "apples"

125. Note: Indexes start from zero

126. print $random_scalars[2]; # prints "dave cross"

127. Note use of $ as individual element of an array is a scalar

128. Array Slices Returns a list of elements from an array

129. print @fruits[0,2,4]; # prints "apples", "guavas", # "grapes"

130. print @fruits[1 .. 3]; # prints "oranges", "guavas", # "passionfruit"

131. Note use of @ as we are accessing more than one element of the array

132. Setting Array Values $array[4] = 'something';

133. $array[400] = 'something else';

134. Also with slices

135. @array[4, 7 .. 9] = ('four','seven', 'eight','nine');

136. @array[1, 2] = @array[2, 1];

137. Doesn't need to be an array ($x, $y) = ($y, $x);

138. Array Size $#array is the index of the last element in @array

139. Therefore $#array + 1 is the number of elements

140. $count = @array;

141. Does the same thing and is easier to understand

142. Hash Variables Hashes implement “look-up tables” or “dictionaries”

143. Initialised with a list

144. %french = ('one', 'un', 'two', 'deux', 'three', 'trois');

145. Fat Comma The “fat comma” (=>) is easier to understand

146. %german = (one => 'ein', two => 'zwei', three => 'drei');

147. Accessing Hash Values $three = $french{three};

148. print $german{two};

149. As with arrays, notice the use of $ to indicate that we're accessing a single value

150. Hash Slices Just like array slices

151. Returns a list of elements from a hash

152. print @french{'one','two','three'}; # prints "un", "deux" & "trois"

153. Again, note use of @ as we are accessing more than one value from the hash

154. Setting Hash Values $hash{foo} = 'something';

155. $hash{bar} = 'something else';

156. Also with slices

157. @hash{'foo', 'bar'} = ('something', 'else');

158. @hash{'foo', 'bar'} = @hash{'bar', 'foo'};

159. More About Hashes Hashes are not sorted

160. There is no equivalent to $#array

161. print %hash is unhelpful

162. We'll see ways round these restrictions later

163. Special Perl Variables Perl has many special variables

164. Many of them have punctuation marks as names

165. Others have names in ALL_CAPS

166. They are documented in perlvar

167. The Default Variable Many Perl operations either set $_ or use its value if no other is given

168. print; # prints the value of $_

169. If a piece of Perl code seems to be missing a variable, then it's probably using $_

170. Think of “it” or “that” in English

171. Using $_ while (<FILE>) { if (/regex/) { print; } }

172. Three uses of $_

173. A Special Array @ARGV

174. Contains your programs command line arguments

175. my $num = @ARGV; print "$num arguments: @ARGV\n";

176. perl printargs.pl foo bar baz

177. A Special Hash %ENV

178. Contains the environment variables that your script has access to.

179. Keys are the variable names

180. Values are the… well… values!

181. print $ENV{PATH};

182. Input and Output

183. Input and Output Programs become more useful with input and output

184. We'll see more input and output methods later in the day

185. But here are some simple methods

186. Output The easiest way to get data out of a Perl program is to use print

187. print “Hello world\n”;

188. Input The easiest way to get data into a Perl program is to read from STDIN

189. $input = <STDIN>;

190. < ... > is the “read from filehandle” operator

191. STDIN is the standard input filehandle

192. A Complete Example #!/usr/bin/perl print 'What is your name: '; $name = <STDIN>; print “Hello $name”;

193. Operators and Functions

194. Operators and Functions What are operators and functions?

195. “Things” that do “stuff”

196. Routines built into Perl to manipulate data

197. Other languages have a strong distinction between operators and functions in Perl that distinction can be a bit blurred See perlop and perlfunc

198. Arithmetic Operators Standard arithmetic operations add (+), subtract (-), multiply (*), divide (/)‏

199. Less standard operations modulus (%), exponentiation (**)‏

200. $speed = $distance / $time;

201. $vol = $length * $breadth * $height;

202. $area = $pi * ($radius ** 2);

203. $odd = $number % 2;

204. Shortcut Operators Often need to do things like

205. $total = $total + $amount;

206. Can be abbreviated to

207. $total += $amount;

208. Even shorter

209. $x++; # same as $x += 1 or $x = $x + 1 $y--; # same as $y -= 1 or $y = $y - 1

210. Subtle difference between $x++ and ++$x

211. String Operators Concaternation (.)

212. $name = $firstname . ' ' $surname;

213. Repetition (x)

214. $line = '-' x 80; $police = 'hello ' x 3;

215. Shortcut versions available

216. $page .= $line; # $page = $page . $line

217. $thing x= $i; # $thing = $thing x $i

218. File Test Operators Check various attributes of a file

219. -e $file does the file exist

220. -r $file is the file readable

221. -w $file is the file writeable

222. More File Test Operators Check various attributes of a file

223. -d $file is the file a directory

224. -f $file is the file a normal file

225. -T $file is a text file

226. -B $file is a binary file

227. Functions Have longer names than operators

228. Can take more arguments than operators

229. Arguments follow the function name

230. See perlfunc for a complete list of Perl's built-in functions

231. Function Return Values Functions can return scalars or lists (or nothing)‏

232. $age = 29.75; $years = int($age);

233. @list = ('a', 'random', 'collection', 'of', 'words'); @sorted = sort(@list); # a collection of random words

234. String Functions length returns the length of a string

235. $len = length $a_string;

236. uc and lc return upper and lower case versions of a string

237. $string = 'MiXeD CaSe'; print "$string\n", uc $string, "\n", lc $string;

238. See also ucfirst and lcfirst

239. More String Functions chop removes the last character from a string and returns it

240. $word = 'word'; $letter = chop $word;

241. chomp removes the last character only if it is a newline and returns true or false appropriately

242. Substrings substr returns substrings from a string

243. $string = 'Hello world'; print substr($string, 0, 5); # prints 'Hello'

244. You can also assign to a substring

245. substr($string, 0, 5) = 'Greetings'; print $string; # prints 'Greetings world'

246. Numeric Functions abs returns the absolute value

247. cos , sin , tan standard trigonometric functions

248. exp exponentiation using e

249. log logarithm to base e

250. rand returns a random number

251. sqrt returns the square root

252. Array Manipulation push adds a new element to the end of an array

253. push @array, $value;

254. pop removes and returns the last element in an array

255. $value = pop @array;

256. shift and unshift do the same for the start of an array

257. Array Manipulation sort returns a sorted list it does not sort the list in place @sorted = sort @array;

258. sort does a lot more besides, see the docs (perldoc -f sort)‏

259. reverse returns a reversed list

260. @reverse = reverse @array;

261. Arrays and Strings join takes an array and returns a string

262. @array = (1 .. 5); $string = join ', ', @array; # $string is '1, 2, 3, 4, 5'

263. split takes a string and converts it into an array

264. $string = '1~2~3~4~5'; @array = split(/~/, $string); # @array is (1, 2, 3, 4, 5)‏

265. Hash Functions delete removes a key/value pair from a hash

266. exists tells you if an element exists in a hash

267. keys returns a list of all the keys in a hash

268. values returns a list of all the values in a hash

269. File Operations open opens a file and associates it with a filehandle

270. open(my $file, '<', 'in.dat');

271. You can then read the file with <$file>

272. $line = <$file>; # one line

273. @lines = <$file>; # all lines

274. Finally, close the file with close

275. close($file);

276. Other File Functions read to read a fixed number of bytes into a buffer

277. $bytes = read(FILE, $buffer, 1024);

278. seek to move to a random position in a file

279. seek(FILE, 0, 0);

280. Other File Functions tell to get current file position

281. $where = tell FILE;

282. truncate to truncate file to given size

283. truncate FILE, $where;

284. Writing to Files Open file in write mode

285. open my $file, '>', 'out.dat'; # overwrite

286. open my $file, '>>', 'out.dat'; # append

287. Write to file using print

288. print $file “some data\n”;

289. Note lack of comma

290. Time Functions time returns the number of seconds since midnight Jan 1st 1970

291. $now = time;

292. localtime converts that into more usable values

293. ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) = localtime($now);

294. localtime Caveats $mon is 0 to 11

295. $year is years since 1900

296. $wday is 0 (Sun) to 6 (Sat)‏

297. localtime Shortcuts It's common to use localtime on the current time

298. @time_bits = localtime(time);

299. Call to time can be omitted

300. @time_bits = localtime;

301. Use array slices

302. ($d, $m, $y) = (localtime)[3 .. 5];

303. Date & Time Formats You can get formatted dates by fiddling the return values from localtime

304. Easier to use strftime (from POSIX.pm)

305. use POSIX 'strftime';

306. print strftime('%Y-%m-%d', localtime);

307. Date & Time Formats Format followed by list of date/time values

308. Format is POSIX standard Like UNIX date command print strftime('%d %B %y', localtime);

309. print strftime('%H:%M:%S', localtime);

310. Conditional Constructs

311. Conditional Constructs Conditional constructs allow us to choose different routes of execution through the program

312. This makes for far more interesting programs

313. The unit of program execution is a block of code

314. Blocks are delimited with braces { … }

315. Conditional Constructs Conditional blocks are controlled by the evaluation of an expression to see if it is true or false

316. But what is truth?

317. What is Truth? In Perl it's easier to answer the question "what is false?"

318. 0 (the number zero)‏

319. '' (the empty string)‏

320. undef (an undefined value)‏

321. () (an empty list)‏

322. Everything else is true

323. Comparison Operators Compare two values in some way

324. Are they equal $x == $y or $x eq $y

325. $x != $y or $x ne $y Is one greater than another $x > $y or $x gt $y

326. $x >= $y or $x ge $y

327. Comparison Operators Is one less than another $x < $y or $x lt $y

328. $x <= $y or $x le $y

329. Comparison Examples 62 > 42 # true

330. '0' == (3 * 2) - 6 # true

331. 'apple' gt 'banana' # false

332. 'apple' == 'banana' # true(!)‏

333. 1 + 2 == '3 bears' # true

334. 1 + 3 == 'three' # false

335. Boolean Operators Combine conditional expressions

336. EXPR_1 and EXPR_2 true if both EXPR_1 and EXPR_2 are true EXPR_1 or EXPR_2 true if either EXPR_1 or _EXPR_2 are true Alternative syntax && for and and || for or

337. Different precedence though

338. Short-Circuit Operators EXPR_1 or EXPR_2

339. Only need to evaluate EXPR_2 if EXPR_1 evaluates as false

340. We can use this to make code easier to follow

341. open FILE, 'something.dat' or die "Can't open file: $!";

342. @ARGV == 2 or print $usage_msg;

343. if if - our first conditional

344. if (EXPR) { BLOCK }

345. Only executes BLOCK if EXPR is true

346. if ($name eq 'Doctor') { regenerate(); }

347. if ... else ... if … else ... - an extended if

348. if (EXPR) { BLOCK1 } else { BLOCK2 }

349. If EXPR is true, execute BLOCK1, otherwise execute BLOCK2

350. if ($name eq 'Doctor') { regenerate(); } else { die "Game over!\n"; }

351. if ... elsif ... else ... if … elsif … else … - even more control

352. if (EXPR1) { BLOCK1 } elsif (EXPR2) { BLOCK2 } else { BLOCK3 }

353. if ... elsif ... else ... If EXPR1 is true, execute BLOCK1 else if EXPR2 is true, execute BLOCK2 otherwise execute BLOCK3

354. if ... elsif ... else ... An example

355. if ($name eq 'Doctor') { regenerate(); } elsif ($tardis_location eq $here) { escape(); } else { die "Game over!\n"; }

356. while while - repeat the same code

357. while (EXPR) { BLOCK }

358. Repeat BLOCK while EXPR is true

359. while ($dalek_prisoners) { print "Ex-ter-min-ate\n"; $dalek_prisoners--; }

360. until until - the opposite of while

361. until (EXPR) { BLOCK }

362. Execute BLOCK until EXPR is true

363. until ($regenerations == 12) { print "Regenerating\n"; regenerate(); $regenerations++; }

364. for for - more complex loops

365. for (INIT; EXPR; INCR) { BLOCK }

366. Like C

367. Execute INIT If EXPR is false, exit loop, otherwise execute BLOCK, execute INCR and retest EXPR

368. for An example

369. for ($i = 1; $i <= 10; $i++) { print "$i squared is ", $i * $i, "\n"; }

370. Used surprisingly rarely

371. foreach foreach - simpler looping over lists

372. foreach VAR (LIST) { BLOCK }

373. For each element of LIST, set VAR to equal the element and execute BLOCK

374. foreach $i (1 .. 10) { print "$i squared is ", $i * $i, "\n"; }

375. foreach Another example

376. my %months = (Jan => 31, Feb => 28, Mar => 31, Apr => 30, May => 31, Jun => 30, … ); foreach (keys %months) { print "$_ has $months{$_} days\n"; }

377. Using while Loops Taking input from STDIN

378. while (<STDIN>) { print; }

379. This is the same as

380. while (defined($_ = <STDIN>)) { print $_; }

381. Breaking Out of Loops next – jump to next iteration of loop

382. last – jump out of loop

383. redo – jump to start of same iteration of loop

384. Subroutines

385. Subroutines Self-contained "mini-programs" within your program

386. Make it easy to repeat code

387. Subroutines have a name and a block of code

388. sub NAME { BLOCK }

389. Subroutine Example sub exterminate { print "Ex-Ter-Min-Ate!!\n"; $timelords--; }

390. Calling a Subroutine &exterminate;

391. exterminate();

392. exterminate;

393. last one only works if function has been predeclared

394. Subroutine Arguments Functions become far more useful if you can pass arguments to them

395. exterminate('The Doctor');

396. Arguments end up in the @_ array within the function

397. Subroutine Arguments sub exterminate { my ($name) = @_; print "Ex-Ter-Min-Ate $name\n"; $timelords--; }

398. Multiple Arguments As @_ is an array it can contain multiple arguments

399. sub exterminate { foreach (@_) { print "Ex-Ter-Min-Ate $_\n"; $timelords--; } }

400. Calling Subroutines A subtle difference between &my_sub and my_sub()‏

401. &my_sub passes on the contents of @_ to the called subroutine

402. sub first { &second }; sub second { print @_ }; first('some', 'random', 'data');

403. You usually don't want to do that

404. By Value or Reference Passing by value passes the value of the variable into the subroutine. Changing the argument doesn't alter the external variable

405. Passing by reference passes the actual variable. Changing the argument alters the external value

406. Perl allows you to choose

407. Pass By Value Simulating pass by value

408. my ($arg1, $arg2) = @_;

409. Updating $arg1 and $arg2 doesn’t effect anything outside the subroutine

410. Pass By Reference Simulating pass by reference

411. $_[0] = 'whatever';

412. Updating the contents of @_ updates the external values

413. Returning Values Use return to return a value from a subroutine

414. sub exterminate { if (rand > .25) { print "Ex-Ter-Min-Ate $_[0]\n"; $timelords--; return 1; } else { return; } }

415. Returning a List Subroutines can return lists

416. sub exterminate { my @exterminated; foreach (@_) { if (rand > .25) { print "Ex-Ter-Min-Ate $_\n"; $timelords--; push @exterminated, $_; } } return @exterminated; }

417. Regular Expressions

418. Regular Expressions Patterns that match strings

419. A bit like wild-cards

420. A “mini-language” within Perl Alien DNA The key to Perl's text processing power

421. Sometimes overused!

422. Documented in perldoc perlre

423. Match Operator m/PATTERN/ - the match operator

424. Works on $_ by default

425. In scalar context returns true if the match succeeds

426. In list context returns list of "captured" text

427. m is optional if you use / characters

428. With m you can use any delimiters

429. Match Examples while (<FILE>) { print if /foo/; print if /bar/i; print if m|http://|; }

430. Substitutions s/PATTERN/REPLACEMENT/ - the substitution operator

431. Works on $_ by default

432. In scalar context returns true if substitution succeeds

433. In list context returns number of replacements

434. Can choose any delimiter

435. Substitution Examples while (<FILE>) { s/teh/the/gi; s/freind/friend/gi; s/sholud/should/gi; print; }

436. Binding Operator If we want m// or s/// to work on something other than $_ then we need to use the binding operator

437. $name =~ s/Dave/David/;

438. Metacharacters Matching something other than literal text

439. ^ - matches start of string

440. $ - matches end of string

441. . - matches any character (except \n)‏

442. \s - matches a whitespace character

443. \S - matches a non-whitespace character

444. More Metacharacters \d - matches any digit

445. \D - matches any non-digit

446. \w - matches any "word" character

447. \W - matches any "non-word" character

448. \b - matches a word boundary

449. \B - matches anywhere except a word boundary

450. Metacharacter Examples while (<FILE>) { print if m|^http|; print if /\bperl\b/; print if /\S/; print if /\$\d\.\d\d/; }

451. Quantifiers Specify the number of occurrences

452. ? - match zero or one

453. * - match zero or more

454. + - match one or more

455. {n} - match exactly n

456. {n,} - match n or more

457. {n,m} - match between n and m

458. Quantifier Examples while (<FILE>) { print if /whiske?y/i; print if /so+n/; print if /\d*\.\d+/; print if /\bA\w{3}\b/; }

459. Character Classes Define a class of characters to match

460. /[aeiou]/ # match any vowel

461. Use - to define a contiguous range

462. /[A-Z]/ # match upper case letters

463. Use ^ to match inverse set

464. /[^A-Za-z] # match non-letters

465. Alternation Use | to match one of a set of options

466. /rose|martha|donna/i;

467. Use parentheses for grouping

468. /^(rose|martha|donna)$/i;

469. Capturing Matches Parentheses are also used to capture parts of the matched string

470. The captured parts are in $1 , $2 , etc…

471. while (<FILE>) { if (/^(\w+)\s+(\w+)/) { print "The first word was $1\n"; print "The second word was $2"; } }

472. Returning Captures Captured values are also returned if the match operator is used in list context

473. my @nums = $text =~ /(\d+)/g; print "I found these integers:\n"; print "@nums\n";

474. More Information perldoc perlre

475. perldoc perlretut

476. Mastering Regular Expressions – Jeffrey Freidl

477. Smart Matching

478. Smart Matching Introduced in Perl 5.10

479. Powerful matching operator

480. DWIM

481. Examines operands

482. Decides which match to apply

483. Smart Match Operator ~~

484. New operator

485. Looks a bit like the binding operator ( =~ )

486. Can be used in place of it

487. $some_text =~ /some regex/

488. Can be replaced with

489. $some_text ~~ /some regex/

490. Smarter Matching If one of its operands is a regex

491. ~~ does a regex match

492. Cleverer than that though

493. %hash ~~ /regex/

494. Regex match on hash keys

495. @array ~~ /regex/

496. Regex match on array elements

497. More Smart Matches @array1 ~~ @array2

498. Checks that arrays are the same

499. $scalar ~~ @array

500. Checks scalar exists in array

501. $scalar ~~ %hash

502. Checks scalar is a hash key

503. Smart Scalar Matches What kind of match does this do?

504. $scalar1 ~~ $scalar2

505. It depends

506. If both look like numbers

507. ~~ acts like ==

508. Otherwise

509. ~~ acts like eq

510. Finding and Using Modules

511. Modules A module is a reusuable 'chunk' of code

512. Perl comes with over 100 modules (see “perldoc perlmodlib” for list)

513. Perl has a repository of freely-available modules - the Comprehensive Perl Archive Network (CPAN) http://www.cpan.org

514. http://search.cpan.org

515. Finding Modules http://search.cpan.org

516. Search by: module name

517. distribution name

518. author name Note: CPAN also contains newer versions of standard modules

519. Installing Modules (The Hard Way) Download distribution file MyModule-X.XX.tar.gz Unzip $ gunzip MyModule-X.XX.tar.gz Untar $ tar xvf MyModule-X.XX.tar Change directory $ cd MyModule-X.XX

520. Installing Modules (The Hard Way) Create Makefile $ perl Makefile.PL Build Module $ make Test Build $ make test Install Module $ make install

521. Installing Modules (The Hard Way) Note: May need root permissions for make install

522. You can have your own personal module library

523. perl Makefile.PL PREFIX=~/perl need to adjust @INC

524. Installing Modules (The Easy Way) CPANPLUS.pm is included with newer Perls

525. Automatically carries out installation process

526. Can also handle required modules

527. Installing Modules (The Easy Way) May not work (or may need some configuration) through a firewall

528. May still need to be root Can use 'sudo'

529. Installing Modules (The Easy Way) cpanp [ ... some stuff ... ] CPAN Terminal> install Some::Module [ ... some more stuff ... ] CPAN Terminal> quit

530. Or

531. cpanp -i Some::Module

532. Using Modules Two types of module: Functions vs Objects Functional modules export new subroutines and variables into your program

533. Object modules usually don't

534. Difference not clear cut (e.g. CGI.pm)

535. Using Functional Modules Import defaults:

536. use My::Module;

537. Import optional components:

538. use My::Module qw(my_sub @my_arr);

539. Using Functional Modules Import defined sets of components:

540. use My:Module qw(:advanced);

541. Use imported components:

542. $data = my_sub(@my_arr);

543. Using Object Modules Use the module:

544. use My::Object;

545. Create an object:

546. $obj = My::Object->new; Note: new is just a convention Interact using object's methods

547. $obj->set_name($name);

548. Useful Standard Modules constant

549. Time::Local

550. Text::ParseWords

551. Getopt::Std

552. Cwd

553. File::Basename File::Copy

554. POSIX

555. CGI

556. Carp

557. Benchmark

558. Data::Dumper

559. Useful Non-Standard Modules Template

560. DBI

561. DBIx::Class

562. DateTime

563. HTML::Parser

564. HTML::Tidy LWP

565. WWW::Mechanize

566. Email::Simple

567. XML::LibXML

568. XML::Feed

569. Moose

570. That's All Folks Any Questions?

Introduction to Perl

Recommended

More Related Content

What's hot (20)

Similar to Introduction to Perl (20)

More from Dave Cross (20)

Recently uploaded (20)

Introduction to Perl