This document provides an overview and schedule for a one-day introduction to Perl programming course. It covers what will be taught including creating and running Perl programs, variables, operators, functions, input/output, and more. The schedule includes breaks and lunch and notes resources available online for the slides.

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

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

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

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

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

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

118. Test for it with defined() function

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

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

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

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

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

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

141. $count = @array;

142. Does the same thing and is easier to understand

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

149. print $german{two};

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

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

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

157. Also with slices

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

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

161. There is no equivalent to $#array

162. print %hash is unhelpful

163. We'll see ways round these restrictions later

165. Many of them have punctuation marks as names

166. Others have names in ALL_CAPS

167. They are documented in perlvar

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

173. Three uses of $_

175. Contains your programs command line arguments

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

177. perl printargs.pl foo bar baz

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

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

186. But here are some simple methods

188. print “Hello world”;

190. $input = <STDIN>;

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

192. STDIN is the standard input filehandle

194. Operators and Functions

196. “Things” that do “stuff”

197. Routines built into Perl to manipulate data

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

201. $speed = $distance / $time;

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

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

204. $odd = $number % 2;

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

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

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

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

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

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

232. $len = length $a_string;

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

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

235. See also ucfirst and lcfirst

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

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

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'

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

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

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;

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

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

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

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;

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

287. Note lack of comma

289. $now = time;

290. localtime converts that into more usable values

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

293. $year is years since 1900

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

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

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

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

304. Format followed by list of date/time values

306. Conditional Constructs

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

312. But what is truth?

314. '' (the empty string)‏

315. undef (an undefined value)‏

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

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

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

330. Different precedence though

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

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

337. if (EXPR) { BLOCK }

338. Only executes BLOCK if EXPR is true

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

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

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

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

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

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

350. while (EXPR) { BLOCK }

351. Repeat BLOCK while EXPR is true

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

354. until (EXPR) { BLOCK }

355. Execute BLOCK until EXPR is true

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

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

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

363. Used surprisingly rarely

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

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

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

372. This is the same as

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

375. last – jump out of loop

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

377. Subroutines

379. Make it easy to repeat code

380. Subroutines have a name and a block of code

381. sub NAME { BLOCK }

384. exterminate();

385. exterminate;

386. last one only works if function has been predeclared

388. exterminate('The Doctor');

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

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

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

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

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

399. Perl allows you to choose

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

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

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

410. Regular Expressions

412. A bit like wild-cards

414. Sometimes overused!

415. Documented in perldoc perlre

417. Works on $_ by default

418. In scalar context returns true if the match succeeds

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

420. m is optional if you use / characters

421. With m you can use any delimiters

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

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

432. ^ - matches start of string

433. $ - matches end of string

434. . - matches any character (except )‏

435. - matches a whitespace character

436. - matches a non-whitespace character

438. - matches any non-digit

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

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

441. - matches a word boundary

442. - matches anywhere except a word boundary

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

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

459. /rose|martha|donna/i;

460. Use parentheses for grouping

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

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

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

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

468. perldoc perlretut

469. Mastering Regular Expressions – Jeffrey Freidl

470. Smart Matching

472. Powerful matching operator

473. DWIM

474. Examines operands

475. Decides which match to apply

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/

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

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

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

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

507. http://search.cpan.org

510. distribution name

515. You can have your own personal module library

518. CPANPLUS.pm is included with newer Perls

519. Automatically carries out installation process

520. Can also handle required modules

523. Or

524. cpanp -i Some::Module

526. Object modules usually don't

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

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

537. use My::Object;

538. Create an object:

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

542. Time::Local

543. Text::ParseWords

544. Getopt::Std

545. Cwd

547. POSIX

548. CGI

549. Carp

550. Benchmark

551. Data::Dumper

553. DBI

554. DBIx::Class

555. DateTime

556. HTML::Parser

558. WWW::Mechanize

559. Email::Simple

560. XML::LibXML

561. XML::Feed

562. Moose

564. See you tomorrow