Introduction to Perl - Day 1

1. Introduction to Perl Day 1 An Introduction to Perl Programming 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:30 – Begin

14. 11:00 – Coffee break (30 mins)

15. 13:00 – Lunch (90 mins)

16. 14:30 – Begin

17. 16:00 – Coffee break (30 mins)

18. 18:00 – End

19. Resources Slides available on-line http://mag-sol.com/train/public/2009-02/yapc 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 Many 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. Use a backslash to escape special characters in double quoted strings

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

111. Better Quotes This can look ugly

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

113. This is a tidier alternative

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

115. Also works for single quotes

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

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

118. Test for it with defined() function

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

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

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

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

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

124. Array Elements Accessing individual elements of an array

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

126. Note: Indexes start from zero

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

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

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

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

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

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

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

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

135. Also with slices

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

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

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

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

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

141. $count = @array;

142. Does the same thing and is easier to understand

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

144. Initialised with a list

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

146. “fat comma” (=>) is easier to understand

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

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

149. print $german{two};

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

151. Hash Slices Just like array slices

152. Returns a list of elements from a hash

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

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

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

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

157. Also with slices

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

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

160. More About Hashes Hashes are not sorted

161. There is no equivalent to $#array

162. print %hash is unhelpful

163. We'll see ways round these restrictions later

164. Special Perl Variables Perl has many special variables

165. Many of them have punctuation marks as names

166. Others have names in ALL_CAPS

167. They are documented in perlvar

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

169. print; # prints the value of $_

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

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

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

173. Three uses of $_

174. A Special Array @ARGV

175. Contains your programs command line arguments

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

177. perl printargs.pl foo bar baz

178. A Special Hash %ENV

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

180. Keys are the variable names

181. Values are the… well… values!

182. print $ENV{PATH};

183. Input and Output

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

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

186. But here are some simple methods

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

188. print “Hello world\n”;

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

190. $input = <STDIN>;

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

192. STDIN is the standard input filehandle

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

194. Operators and Functions

195. Operators and Functions What are operators and functions?

196. “Things” that do “stuff”

197. Routines built into Perl to manipulate data

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

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

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

201. $speed = $distance / $time;

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

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

204. $odd = $number % 2;

205. Shortcut Operators Often need to do things like $total = $total + $amount;

206. Can be abbreviated to $total += $amount;

207. Even shorter $x++; # same as $x += 1 or $x = $x + 1 $y--; # same as $y -= 1 or $y = $y - 1

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

209. String Operators Concaternation (.)

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

211. Repetition (x)

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

213. Shortcut versions available

214. $page .= $line; # $page = $page . $line

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

216. File Test Operators Check various attributes of a file

217. -e $file does the file exist

218. -r $file is the file readable

219. -w $file is the file writeable

220. -d $file is the file a directory

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

222. -T $file is a text file

223. -B $file is a binary file

224. Functions Have longer names than operators

225. Can take more arguments than operators

226. Arguments follow the function name

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

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

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

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

231. String Functions length returns the length of a string

232. $len = length $a_string;

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

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

235. See also ucfirst and lcfirst

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

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

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

239. Substrings substr returns substrings from a string

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

241. Unlike many other languages you can assign to a substring

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

243. Numeric Functions abs returns the absolute value

244. cos , sin , tan standard trigonometric functions

245. exp exponentiation using e

246. log logarithm to base e

247. rand returns a random number

248. sqrt returns the square root

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

250. push @array, $value;

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

252. $value = pop @array;

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

254. Array Manipulation sort returns a sorted list (it does not sort the list in place)

255. @sorted = sort @array;

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

257. reverse returns a reversed list

258. @reverse = reverse @array;

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

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

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

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

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

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

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

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

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

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

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

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

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

272. Finally, close the file with close

273. close($file);

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

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

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

277. seek(FILE, 0, 0);

278. tell to get current file position

279. $where = tell FILE;

280. truncate to truncate file to given size

281. truncate FILE, $where;

282. Writing to Files Open file in write mode

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

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

285. Write to file using print

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

287. Note lack of comma

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

289. $now = time;

290. localtime converts that into more usable values

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

292. localtime Caveats $mon is 0 to 11

293. $year is years since 1900

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

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

296. @time_bits = localtime(time);

297. Call to time can be omitted

298. @time_bits = localtime;

299. Use array slices

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

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

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

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

304. Format followed by list of date/time values

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

306. Conditional Constructs

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

308. This makes for far more interesting programs

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

310. Blocks are delimited with braces { … }

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

312. But what is truth?

313. What is Truth? In Perl it's easier to answer the question "what is false?" 0 (the number zero)‏

314. '' (the empty string)‏

315. undef (an undefined value)‏

316. () (an empty list)‏ Everything else is true

317. Comparison Operators Compare two values in some way

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

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

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

321. Also < ( lt ) and <= ( le )‏

322. Comparison Examples 62 > 42 # true

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

324. 'apple' gt 'banana' # false

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

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

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

328. Boolean Operators Combine two or more conditional expressions into one

329. 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

330. Different precedence though

331. Short-Circuit Operators EXPR_1 or EXPR_2

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

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

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

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

336. if if - our first conditional

337. if (EXPR) { BLOCK }

338. Only executes BLOCK if EXPR is true

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

340. if ... else ... if … else ... - an extended if

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

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

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

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

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

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

347. if ... elsif ... else ... An example

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

349. while while - repeat the same code

350. while (EXPR) { BLOCK }

351. Repeat BLOCK while EXPR is true

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

353. until until - the opposite of while

354. until (EXPR) { BLOCK }

355. Execute BLOCK until EXPR is true

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

357. for for - more complex loops

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

359. Like C

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

361. for An example

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

363. Used surprisingly rarely

364. foreach foreach - simpler looping over lists

365. foreach VAR (LIST) { BLOCK }

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

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

368. foreach Another example

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

370. Using while Loops Taking input from STDIN

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

372. This is the same as

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

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

375. last – jump out of loop

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

377. Subroutines

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

379. Make it easy to repeat code

380. Subroutines have a name and a block of code

381. sub NAME { BLOCK }

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

383. Calling a Subroutine &exterminate;

384. exterminate();

385. exterminate;

386. last one only works if function has been predeclared

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

388. exterminate('The Doctor');

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

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

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

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

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

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

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

396. You usually don't want to do that

397. 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

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

399. Perl allows you to choose

400. By Value or Reference Simulating pass by value

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

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

403. Simulating pass by reference

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

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

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

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

408. Returning a List Subroutines can return lists

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

410. Regular Expressions

411. Regular Expressions Patterns that match strings

412. A bit like wild-cards

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

414. Sometimes overused!

415. Documented in perldoc perlre

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

417. Works on $_ by default

418. In scalar context returns true if the match succeeds

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

420. m is optional if you use / characters

421. With m you can use any delimiters

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

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

424. Works on $_ by default

425. In scalar context returns true if substitution succeeds

426. In list context returns number of replacements

427. Can choose any delimiter

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

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

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

431. Metacharacters Matching something other than literal text

432. ^ - matches start of string

433. $ - matches end of string

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

435. \s - matches a whitespace character

436. \S - matches a non-whitespace character

437. More Metacharacters \d - matches any digit

438. \D - matches any non-digit

439. \w - matches any "word" character

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

441. \b - matches a word boundary

442. \B - matches anywhere except a word boundary

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

444. Quantifiers Specify the number of occurrences

445. ? - match zero or one

446. * - match zero or more

447. + - match one or more

448. {n} - match exactly n

449. {n,} - match n or more

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

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

452. Character Classes Define a class of characters to match

453. /[aeiou]/ # match any vowel

454. Use - to define a contiguous range

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

456. Use ^ to match inverse set

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

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

459. /rose|martha|donna/i;

460. Use parentheses for grouping

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

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

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

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

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

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

467. More Information perldoc perlre

468. perldoc perlretut

469. Mastering Regular Expressions – Jeffrey Freidl

470. Smart Matching

471. Smart Matching Introduced in Perl 5.10

472. Powerful matching operator

473. DWIM

474. Examines operands

475. Decides which match to apply

476. Smart Match Operator ~~

477. New operator

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

479. Can be used in place of it

480. $some_text =~ /some regex/

481. Can be replaced with

482. $some_text ~~ /some regex/

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

484. ~~ does a regex match

485. Cleverer than that though

486. %hash ~~ /regex/

487. Regex match on hash keys

488. @array ~~ /regex/

489. Regex match on array elements

490. More Smart Matches @array1 ~~ @array2

491. Checks that arrays are the same

492. $scalar ~~ @array

493. Checks scalar exists in array

494. $scalar ~~ %hash

495. Checks scalar is a hash key

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

497. $scalar1 ~~ $scalar2

498. It depends

499. If both look like numbers

500. ~~ acts like ==

501. Otherwise

502. ~~ acts like eq

503. Finding and Using Modules

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

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

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

507. http://search.cpan.org

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

509. Search by: module name

510. distribution name

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

512. 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

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

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

515. You can have your own personal module library

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

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

518. CPANPLUS.pm is included with newer Perls

519. Automatically carries out installation process

520. Can also handle required modules

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

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

523. Or

524. cpanp -i Some::Module

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

526. Object modules usually don't

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

528. Using Functional Modules Import defaults:

529. use My::Module;

530. Import optional components:

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

532. Import defined sets of components:

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

534. Use imported components:

535. $data = my_sub(@my_arr);

536. Using Object Modules Use the module:

537. use My::Object;

538. Create an object:

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

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

541. Useful Standard Modules constant

542. Time::Local

543. Text::ParseWords

544. Getopt::Std

545. Cwd

546. File::Basename File::Copy

547. POSIX

548. CGI

549. Carp

550. Benchmark

551. Data::Dumper

552. Useful Non-Standard Modules Template

553. DBI

554. DBIx::Class

555. DateTime

556. HTML::Parser

557. HTML::Tidy LWP

558. WWW::Mechanize

559. Email::Simple

560. XML::LibXML

561. XML::Feed

562. Moose

563. That's All Folks Any Questions?

564. See you tomorrow

Introduction to Perl - Day 1

More Related Content

What's hot (20)

Viewers also liked (16)

Similar to Introduction to Perl - Day 1 (20)

More from Dave Cross (20)

Recently uploaded (20)

Introduction to Perl - Day 1