The Beginning Perl course that I ran for the UKUUG in Feb 2009.

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

3. Creating and running a Perl program

4. Input and Output

5. Perl variables

6. Operators and Functions

7. Conditional Constructs

9. Regular Expressions

10. References

11. Smart Matching

12. Finding and using Modules

13. Further Information

15. 11:15 – Coffee break

16. 13:00 – Lunch

17. 14:00 – Begin

18. 15:30 – Coffee break

19. 17:00 – End

21. What is Perl?

23. Pathologically Eclectic Rubbish Lister

24. "Perl" is the language

25. "perl" is the compiler

26. Never "PERL"

28. System administration tasks

29. CGI and web programming

30. Database interaction

31. Other Internet programming

33. NASA

35. Free (open source)‏

36. Fast

37. Flexible

38. Secure

39. Fun

42. Impatience

44. Creating and Running a Perl Program

46. Put this in a file called hello.pl

48. $ perl hello.pl

50. Make program executable $ chmod +x hello.pl

51. Run from command line $ ./hello.pl

53. Start with a hash ( # )‏

54. Continue to end of line

55. # This is a hello world program print "Hello, world!"; # print

57. For example, -w turns on warnings

58. Use on command line perl -w hello.pl

59. Or on shebang line #!/usr/bin/perl -w

60. Perl variables

63. put new data in it

65. User variable names may not start with numbers

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

68. Array variables start with @

74. my $name = "Arthur";

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

76. my $meaning_of_life = 42;

77. my $number_less_than_1 = 0.000001;

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

80. Add int to a floating point number my $sum = $meaning_of_life + $number_less_than_1;

81. Putting a number into a string print "$name says, 'The meaning of life is $sum.'";

83. Double quotes do my $invline = "24 widgets @ $price each";

84. Use a backslash to escape special characters in double quoted strings print "He said amp;quot;The price is 300amp;quot;";

86. This is a tidier alternative print qq(He said "The price is 300");

87. Also works for single quotes print q(He said "That's too expensive");

89. Test for it with “defined()” function

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

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

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

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

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

97. Note: Indexes start from zero

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

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

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

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

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

105. Also with slices

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

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

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

111. $count = @array; does the same thing and is easier to understand

113. Initialised with a list %french = ('one', 'un', 'two', 'deux', 'three', 'trois');

114. "fat comma" (=>) is easier to understand %german = (one => 'ein', two => 'zwei', three => 'drei');

116. print $german{two};

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

119. Returns a list of elements from a hash print @french{'one','two','three'}; # prints "un", "deux" & "trois"

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

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

123. Also with slices

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

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

127. There is no equivalent to $#array

128. print %hash is unhelpful

129. We'll see ways round these restrictions later

131. Many of them have punctuation marks as names

132. Others have names in ALL_CAPS

133. They are documented in perlvar

135. print; # prints the value of $_

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

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

139. Three uses of $_

141. Contains your programs command line arguments

142. perl printargs.pl foo bar baz

143. my $num = @ARGV; print "$num arguments: @ARGV";

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

146. Keys are the variable names Values are the… well… values!

147. print $ENV{PATH};

148. Input and Output

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

151. But here are some simple methods

153. print “Hello world”;

155. $input = <STDIN>;

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

157. STDIN is the standard input filehandle

159. Operators and Functions

161. &quot;Things&quot; that do &quot;stuff&quot;

162. Routines built into Perl to manipulate data

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

166. $speed = $distance / $time; $vol = $length * $breadth * $height; $area = $pi * ($radius ** 2); $odd = $number % 2;

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

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

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

172. Repetition (x) $line = '-' x 80; $police = 'hello ' x 3;

173. Shortcut versions available $page .= $line; # $page = $page . $line $thing x= $i; # $thing = $thing x $i

175. -e $file does the file exist

176. -r $file is the file readable

177. -w $file is the file writeable

178. -d $file is the file a directory

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

180. -T $file is a text file

181. -B $file is a binary file

183. Can take more arguments than operators

184. Arguments follow the function name

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

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

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

190. uc and lc return upper and lower case versions of a string $string = 'MiXeD CaSe'; print &quot;$string&quot;, uc $string, &quot;&quot;, lc $string;

191. See also ucfirst and lcfirst

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

195. Unlike many other languages you can assign to a substring substr($string, 0, 5) = 'Greetings'; print $string; # prints 'Greetings world'

197. cos , sin , tan standard trigonometric functions

198. exp exponentiation using e

199. log logarithm to base e

200. rand returns a random number

201. sqrt returns the square root

203. pop removes and returns the last element in an array $value = pop @array;

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

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

207. reverse returns a reversed list @reverse = reverse @array;

209. split takes a string and converts it into an array $string = '1~2~3~4~5'; @array = split(/~/, $string); # @array is (1, 2, 3, 4, 5)‏

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

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

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

215. You can then read the file with <FILE> $line = <FILE>; # one line @lines = <FILE>; # all lines

216. Finally, close the file with close close(FILE);

218. seek to move to a random position in a file seek(FILE, 0, 0);

219. tell to get current file position $where = tell FILE;

220. truncate to truncate file to given size truncate FILE, $where;

222. $now = time;

223. localtime converts that into more usable values

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

226. $year is years since 1900

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

229. @time_bits = localtime(time);

230. Call to time can be omitted

231. @time_bits = localtime;

232. Use array slices

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

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

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

237. Format followed by list of date/time values

239. Conditional Constructs

241. This makes for far more interesting programs

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

243. Blocks are delimited with braces { … }

245. But what is truth?

247. '' (the empty string)‏

248. undef (an undefined value)‏

251. Is one greater than another $x > $y or $x gt $y $x >= $y or $x ge $y

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

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

255. 'apple' gt 'banana' # false

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

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

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

260. EXPR_1 and EXPR_2 true if both EXPR_1 and EXPR_2 are true

261. EXPR_1 or _EXPR_2 true if either EXPR_1 or _EXPR_2 are true

262. Alternative syntax && for and and || for or

263. Different precedence though

265. We can use this to make code easier to follow open FILE, 'something.dat' or die &quot;Can't open file: $!&quot;;

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

268. if (EXPR) { BLOCK }

269. Only executes BLOCK if EXPR is true if ($name eq 'Doctor') { regenerate(); }

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

272. if ($name eq 'Doctor') { regenerate(); } else { die &quot;Game over!&quot;; }

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

277. Repeat BLOCK while EXPR is true while ($dalek_prisoners) { print &quot;Ex-ter-min-ate&quot;; $dalek_prisoners--; }

279. Execute BLOCK until EXPR is true until ($regenerations == 12) { print &quot;Regenerating&quot;; regenerate(); $regenerations++; }

281. Like C

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

284. Used surprisingly rarely

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

287. foreach $i (1 .. 10) { print &quot;$i squared is &quot;, $i * $i, &quot;&quot;; }

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

291. This is the same as while (defined($_ = <STDIN>)) { print $_; }

293. last - jump out of loop

294. redo - jump to start of same iteration of loop

295. Subroutines

297. Make it easy to repeat code

298. Subroutines have a name and a block of code

299. sub NAME { BLOCK }

302. exterminate();

303. exterminate;

304. last one only works if function has been predeclared

306. exterminate('The Doctor');

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

308. sub exterminate { my ($name) = @_; print &quot;Ex-Ter-Min-Ate $name&quot;; $timelords--; }

310. sub exterminate { foreach (@_) { print &quot;Ex-Ter-Min-Ate $_&quot;; $timelords--; } }

312. &my_sub passes on the contents of @_ to the called subroutine sub first { &second }; sub second { print @_ }; first('some', 'random', 'data');

313. You usually don't want to do that

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

316. Perl allows you to choose

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

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

320. Simulating pass by reference

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

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

325. Regular Expressions

327. A bit like wild-cards

329. Sometimes overused!

330. Documented in perldoc perlre

332. Works on $_ by default

333. In scalar context returns true if the match succeeds

334. In list context returns list of &quot;captured&quot; text

335. m is optional if you use / characters

336. With m you can use any delimiters

339. Works on $_ by default

340. In scalar context returns true if substitution succeeds

341. In list context returns number of replacements

342. Can choose any delimiter

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

347. ^ - matches start of string

348. $ - matches end of string

349. . - matches any character (except )‏

350. - matches a whitespace character

351. - matches a non-whitespace character

353. - matches any non-digit

354. - matches any &quot;word&quot; character

355. - matches any &quot;non-word&quot; character

356. - matches a word boundary

357. - matches anywhere except a word boundary

360. ? - match zero or one

361. * - match zero or more

362. + - match one or more

363. {n} - match exactly n

364. {n,} - match n or more

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

368. /[aeiou]/ # match any vowel

369. Use - to define a contiguous set

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

371. Use ^ to match inverse set

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

374. /rose|martha|donna/i;

375. Use parentheses for grouping

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

378. The captured parts are in $1, $2, etc… while (<FILE>) { if (/^(+)+(+)/) { print &quot;The first word was $1&quot;; print &quot;The second word was $2&quot;; } }

380. my @nums = $text =~ /(+)/g; print &quot;I found these integers:&quot;; print &quot;@nums&quot;;

382. perldoc perlretut

383. Mastering Regular Expressions – Jeffrey Freidl

384. References

386. A reference is a unique way to refer to a variable.

387. A reference can always fit into a scalar variable

388. A reference looks like SCALAR(0x20026730)

390. Can now treat it just like any other scalar $var = $scalar_ref; $refs[0] = $array_ref; $another_ref = $refs[0];

392. { LIST } creates anonymous hash and returns a reference $href = { 1 => 'one', 2 => 'two' }; $href = { %hash };

394. Second method creates a copy of the array

396. Whole array

397. @array = @{$aref};

398. @rev = reverse @{$aref};

399. Single elements

400. $elem = ${$aref}[0];

401. ${$aref}[0] = 'foo';

403. Whole hash

404. %hash = %{$href};

405. @keys = keys %{$href};

406. Single elements

407. $elem = ${$href}{key};

408. ${$href}{key} = 'foo';

410. Instead of ${$aref}[0] you can use $aref->[0]

411. Instead of ${$href}{key} you can use $href->{key}

413. $aref = [ 1, 2, 3 ]; print ref $aref; # prints ARRAY

414. $href = { 1 => 'one', 2 => 'two' }; print ref $href; # prints HASH

416. Complex data structures

418. @arr1 = (1, 2, 3); @arr2 = (4, 5, 6); check_size(@arr1, @arr2); sub check_size { my (@a1, @a2) = @_; print @a1 == @a2 ? 'Yes' : 'No'; }

420. All elements end up in @a1

421. How do we fix it?

422. Pass references to the arrays

425. Try to create a 2-D array

426. @arr_2d = ((1, 2, 3), (4, 5, 6), (7, 8, 9));

427. @arr_2d contains (1, 2, 3, 4, 5, 6, 7, 8, 9)

428. This is known a array flattening

430. @arr_2d = ([1, 2, 3], [4, 5, 6], [7, 8, 9]);

431. But how do you access individual elements?

432. $arr_2d[1] is ref to array (4, 5, 6)

433. $arr_2d[1]->[1] is element 5

435. $arr_2d = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

436. $arr_2d->[1] is ref to array (4, 5, 6)

437. $arr_2d->[1]->[1] is element 5

438. Can omit intermediate arrows

439. $arr_2d->[1][1]

441. Jones,Martha,UNIT Harkness,Jack,Torchwood Smith,Sarah Jane,Journalist

442. What would be a good data structure?

443. Hash for each record

444. Array of records

445. Array of hashes

447. my @records; my @cols = ('s_name', 'f_name', 'job'); while (<FILE>) { chomp; my %rec; @rec{@cols} = split /,/; push @records, rec; }

448. Using an Array of Hashes foreach (@records) { print &quot;$_->{f_name} &quot;, &quot;$_->{s_name} &quot;. &quot;is a $_->{job}&quot;; }

450. Hash of lists

452. Smart Matching

454. Powerful matching operator

455. DWIM

456. Examines operands

457. Decides which match to apply

459. New operator

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

461. Can be used in place of it

462. $some_text =~ /some regex/

463. Can be replaced with

464. $some_text ~~ /some regex/

466. ~~ does a regex match

467. Cleverer than that though

468. %hash ~~ /regex/

469. Regex match on hash keys

470. @array ~~ /regex/

471. Regex match on array elements

473. Checks that arrays are the same

474. $scalar ~~ @array

475. Checks scalar exists in array

476. $scalar ~~ %hash

477. Checks scalar is a hash key

479. $scalar1 ~~ $scalar2

480. It depends

481. If both look like numbers

482. ~~ acts like ==

483. Otherwise

484. ~~ acts like eq

485. Finding and Using Modules

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

489. http://search.cpan.org

492. distribution name

497. You can have your own personal module library

500. CPANPLUS.pm is included with newer Perls

501. Automatically carries out installation process

502. Can also handle required modules

505. Or

506. cpanp -i Some::Module

508. Object modules usually don't

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

511. Import optional components: use My::Module qw(my_sub @my_arr);

512. Import defined sets of components: use My:Module qw(:advanced);

513. Use imported components: $data = my_sub(@my_arr);

517. Time::Local

518. Text::ParseWords

519. Getopt::Std

520. Cwd

522. POSIX

523. CGI

524. Carp

525. Benchmark

526. Data::Dumper

528. DBI

529. DBIx::Class

530. DateTime

531. HTML::Parser

533. WWW::Mechanize

534. Email::Simple

535. XML::LibXML

536. XML::Feed

537. Moose

538. More Information

541. http://london.pm.org

545. http://www.yapceurope.org

548. Australia

550. Germany, Israel, Pittsburgh, Nordic, Netherlands, France, Belgium, Russia, Minnesota, Austria

553. CGI

554. DBI

555. XML

556. Beginners

557. Advocacy

558. Fun with Perl

560. Intermediate Perl Schwartz, foy & Phoenix (O'Reilly)‏

561. Beginning Perl Cozens (Wrox) http://www.perl.org/books/beginning-perl/

563. The Perl Cookbook (2 nd edition) Christiansen & Torkington (O'Reilly)‏

564. Perl Best Practices Conway (O'Reilly)‏

565. Perl in a Nutshell Siever, Spainhour & Patwardhan (O'Reilly)‏

567. Data Munging with Perl Cross (Manning)‏

568. Advanced Perl Programming Cozens (O'Reilly)‏

569. Perl Medic Scott (Addison Wesley)

571. Programming the Perl DBI Descartes & Bunce (O'Reilly)‏

572. Writing CGI Applications with Perl Meltzer & Michelski (Addison Wesley)‏

573. Practical mod_perl Bekman & Cholet (O'Reilly)‏

574. Perl Template Toolkit Chamberlain, Cross & Wardley