Slides from the Introduction to Perl course, November 2009.

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

3. Creating and running a Perl program

4. Getting help

5. Input and Output

6. Perl variables

7. Operators and Functions

9. Subroutines

10. Regular Expressions

11. Smart Matching

12. Finding and using Modules

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

20. What is Perl?

22. Pathologically Eclectic Rubbish Lister

23. “Perl” is the language

24. “perl” is the compiler

25. Never “PERL”

27. System administration tasks

28. CGI and web programming

29. Database interaction

30. Other Internet programming

32. NASA

34. Free (open source)‏

35. Fast

36. Flexible

37. Secure

38. Fun

41. Impatience

43. Creating and Running a Perl Program

45. print "Hello world";

46. Put this in a file called hello.pl

48. $ perl hello.pl

50. #!/usr/bin/perl

51. Make program executable

52. $ chmod +x hello.pl

53. Run from command line

54. $ ./hello.pl

56. Start with a hash (#)‏

57. Continue to end of line

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

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

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

74. perldata

75. perlsyn

76. perlfaq

77. perlstyle

78. perlcheat

79. Many many more

80. Perl Variables

83. To retrieve the data stored in it

85. User variable names may not start with numbers

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

88. Array variables start with @

93. use strict; my $var;

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

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.'";

106. my $price = '$9.95';

107. Double quotes do

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

110. print "He said amp;quot;The price is 300amp;quot;";

111. This can look ugly

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

114. Also works for single quotes

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

117. Test for it with defined() function

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

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);

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

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

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];

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

140. $count = @array;

141. Does the same thing and is easier to understand

143. Initialised with a list

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

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

148. print $german{two};

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

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

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

156. Also with slices

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

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

160. There is no equivalent to $#array

161. print %hash is unhelpful

162. We'll see ways round these restrictions later

164. Many of them have punctuation marks as names

165. Others have names in ALL_CAPS

166. They are documented in perlvar

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

172. Three uses of $_

174. Contains your programs command line arguments

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

176. perl printargs.pl foo bar baz

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

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

185. But here are some simple methods

187. print “Hello world”;

189. $input = <STDIN>;

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

191. STDIN is the standard input filehandle

193. Operators and Functions

195. “Things” that do “stuff”

196. Routines built into Perl to manipulate data

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

200. $speed = $distance / $time;

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

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

203. $odd = $number % 2;

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

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

219. -e $file does the file exist

220. -r $file is the file readable

221. -w $file is the file writeable

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

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

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

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

235. $len = length $a_string;

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

237. $string = 'MiXeD CaSe'; print &quot;$string&quot;, uc $string, &quot;&quot;, lc $string;

238. See also ucfirst and lcfirst

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

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

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'

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

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

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

259. reverse returns a reversed list

260. @reverse = reverse @array;

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)‏

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

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);

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

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

279. seek(FILE, 0, 0);

281. $where = tell FILE;

282. truncate to truncate file to given size

283. truncate FILE, $where;

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”;

289. Note lack of comma

291. $now = time;

292. localtime converts that into more usable values

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

295. $year is years since 1900

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

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];

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

305. use POSIX 'strftime';

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

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

310. Conditional Constructs

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 { … }

316. But what is truth?

318. 0 (the number zero)‏

319. '' (the empty string)‏

320. undef (an undefined value)‏

321. () (an empty list)‏

322. Everything else is true

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

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

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

337. Different precedence though

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 &quot;Can't open file: $!&quot;;

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

344. if (EXPR) { BLOCK }

345. Only executes BLOCK if EXPR is true

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

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

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

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

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

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

357. while (EXPR) { BLOCK }

358. Repeat BLOCK while EXPR is true

359. while ($dalek_prisoners) { print &quot;Ex-ter-min-ate&quot;; $dalek_prisoners--; }

361. until (EXPR) { BLOCK }

362. Execute BLOCK until EXPR is true

363. until ($regenerations == 12) { print &quot;Regenerating&quot;; regenerate(); $regenerations++; }

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

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

370. Used surprisingly rarely

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 &quot;$i squared is &quot;, $i * $i, &quot;&quot;; }

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

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

379. This is the same as

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

382. last – jump out of loop

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

384. Subroutines

386. Make it easy to repeat code

387. Subroutines have a name and a block of code

388. sub NAME { BLOCK }

391. exterminate();

392. exterminate;

393. last one only works if function has been predeclared

395. exterminate('The Doctor');

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

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

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

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

406. Perl allows you to choose

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

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

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

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

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

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

417. Regular Expressions

419. A bit like wild-cards

421. Sometimes overused!

422. Documented in perldoc perlre

424. Works on $_ by default

425. In scalar context returns true if the match succeeds

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

427. m is optional if you use / characters

428. With m you can use any delimiters

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

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

439. ^ - matches start of string

440. $ - matches end of string

441. . - matches any character (except )‏

442. - matches a whitespace character

443. - matches a non-whitespace character

445. - matches any non-digit

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

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

448. - matches a word boundary

449. - matches anywhere except a word boundary

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

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

466. /rose|martha|donna/i;

467. Use parentheses for grouping

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

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

471. while (<FILE>) { if (/^(+)+(+)/) { print &quot;The first word was $1&quot;; print &quot;The second word was $2&quot;; } }

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

475. perldoc perlretut

476. Mastering Regular Expressions – Jeffrey Freidl

477. Smart Matching

479. Powerful matching operator

480. DWIM

481. Examines operands

482. Decides which match to apply

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/

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

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

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

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

514. http://search.cpan.org

517. distribution name

522. You can have your own personal module library

525. Automatically carries out installation process

526. Can also handle required modules

530. Or

531. cpanp -i Some::Module

533. Object modules usually don't

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

536. use My::Module;

537. Import optional components:

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

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

541. Use imported components:

542. $data = my_sub(@my_arr);

544. use My::Object;

545. Create an object:

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

549. Time::Local

550. Text::ParseWords

551. Getopt::Std

552. Cwd

554. POSIX

555. CGI

556. Carp

557. Benchmark

558. Data::Dumper

560. DBI

561. DBIx::Class

562. DateTime

563. HTML::Parser

565. WWW::Mechanize

566. Email::Simple

567. XML::LibXML

568. XML::Feed

569. Moose