Beginning Perl

1. Introduction to Perl 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. Input and Output

5. Perl variables

6. Operators and Functions

7. Conditional Constructs

8. What We Will Cover Subroutines

9. Regular Expressions

10. References

11. Smart Matching

12. Finding and using Modules

13. Further Information

14. Schedule 09:45 – Begin

15. 11:15 – Coffee break

16. 13:00 – Lunch

17. 14:00 – Begin

18. 15:30 – Coffee break

19. 17:00 – End

20. Resources Slides available on-line http://mag-sol.com/train/public/2009-02/begin Also see Slideshare http://www.slideshare.net/davorg/slideshows Mailing List http://lists.mag-sol.com/mailman/listinfo/beg2009 Get Satisfaction http://getsatisfaction.com/magnum

21. What is Perl?

22. Perl's Name Practical Extraction and Reporting Language

23. Pathologically Eclectic Rubbish Lister

24. "Perl" is the language

25. "perl" is the compiler

26. Never "PERL"

27. Typical uses of Perl Text processing

28. System administration tasks

29. CGI and web programming

30. Database interaction

31. Other Internet programming

32. Less typical uses of Perl Human Genome Project

33. NASA

34. What is Perl Like? General purpose programming language

35. Free (open source)‏

36. Fast

37. Flexible

38. Secure

39. Fun

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

41. Three virtues of a programmer Laziness

42. Impatience

43. Hubris Share and enjoy!

44. Creating and Running a Perl Program

45. Creating a Perl Program Our first Perl program 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) #!/usr/bin/perl

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

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

52. Perl Comments Add comments to your code

53. Start with a hash ( # )‏

54. Continue to end of line

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

56. Command Line Options Many options to control execution of the program

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

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

62. A variable needs a name to retrieve the data stored in it

63. put new data in it

64. Variable Names Contain alphanumeric characters and underscores

65. User variable names may not start with numbers

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

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

68. Array variables start with @

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

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

71. But it's a very good idea typos

72. scoping Using the strict pragma use strict; my $var;

73. Scalar Variables Store a single item of data

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

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

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

82. Quoting Strings Single quotes don't expand variables or escape sequences my $price = '$9.95';

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

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

85. Better Quotes This can look ugly print "He said \"The price is \$300\"";

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

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

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

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

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

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

95. Array Elements Accessing individual elements of an array

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

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

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

104. Setting Array Values $array[4] = 'something'; $array[400] = 'something else';

105. Also with slices

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

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

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

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

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

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

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

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

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

116. print $german{two};

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

118. Hash Slices Just like array slices

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

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

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

123. Also with slices

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

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

126. More About Hashes Hashes are not sorted

127. There is no equivalent to $#array

128. print %hash is unhelpful

129. We'll see ways round these restrictions later

130. Special Perl Variables Perl has many special variables

131. Many of them have punctuation marks as names

132. Others have names in ALL_CAPS

133. They are documented in perlvar

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

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

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

139. Three uses of $_

140. A Special Array @ARGV

141. Contains your programs command line arguments

142. perl printargs.pl foo bar baz

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

144. A Special Hash %ENV

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

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

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

151. But here are some simple methods

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

153. print “Hello world\n”;

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

155. $input = <STDIN>;

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

157. STDIN is the standard input filehandle

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

159. Operators and Functions

160. Operators and Functions What are operators and functions?

161. "Things" that do "stuff"

162. Routines built into Perl to manipulate data

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

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

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

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

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

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

171. String Operators Concaternation (.) $name = $firstname . ' ' . $surname;

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

174. File Test Operators Check various attributes of a file

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

182. Functions Have longer names than operators

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

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

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

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

189. String Functions length returns the length of a string $len = length $a_string;

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

191. See also ucfirst and lcfirst

192. More String Functions chop removes the last character from a string and returns it $word = 'word'; $letter = chop $word;

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

194. Substrings substr returns substrings from a string $string = 'Hello world'; print substr($string, 0, 5); # prints 'Hello'

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

196. Numeric Functions abs returns the absolute value

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

202. Array Manipulation push adds a new element to the end of an array push @array, $value;

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

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

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

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

208. Arrays and Strings join takes an array and returns a string @array = (1 .. 5); $string = join ' ', @array; # $string is '1 2 3 4 5'

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

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

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

214. File Operations open opens a file and associates it with a filehandle open(FILE, 'in.dat');

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

217. Other File Functions read to read a fixed number of bytes into a buffer $bytes = read(FILE, $buffer, 1024);

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;

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

222. $now = time;

223. localtime converts that into more usable values

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

225. localtime Caveats $mon is 0 to 11

226. $year is years since 1900

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

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

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

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

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

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

237. Format followed by list of date/time values

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

239. Conditional Constructs

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

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

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

245. But what is truth?

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

247. '' (the empty string)‏

248. undef (an undefined value)‏

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

250. Comparison Operators Compare two values in some way are they equal $x == $y or $x eq $y $x != $y or $x ne $y

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

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

253. Comparison Examples 62 > 42 # true

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

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

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

264. Short-Circuit Operators EXPR_1 or EXPR_2 Only need to evaluate EXPR_2 if EXPR_1 evaluates as false

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

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

267. if if - our first conditional

268. if (EXPR) { BLOCK }

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

270. if ... else ... if … else ... - an extended if if (EXPR) { BLOCK1 } else { BLOCK2}

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

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

273. if ... elsif ... else ... if … elsif … else ... - even more control if (EXPR1) { BLOCK1 } elsif (EXPR2) { BLOCK2 } else { BLOCK3 }

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

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

276. while while - repeat the same code while (EXPR) { BLOCK }

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

278. until until - the opposite of while until (EXPR) { BLOCK }

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

280. for for - more complex loops for (INIT; EXPR; INCR) { BLOCK }

281. Like C

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

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

284. Used surprisingly rarely

285. foreach foreach - simpler looping over lists foreach VAR (LIST) { BLOCK }

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

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

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

289. Using while Loops Taking input from STDIN

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

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

292. Breaking Out of Loops next - jump to next iteration of loop

293. last - jump out of loop

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

295. Subroutines

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

297. Make it easy to repeat code

298. Subroutines have a name and a block of code

299. sub NAME { BLOCK }

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

301. Calling a Subroutine &exterminate;

302. exterminate();

303. exterminate;

304. last one only works if function has been predeclared

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

306. exterminate('The Doctor');

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

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

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

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

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

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

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

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

316. Perl allows you to choose

317. By Value or Reference Simulating pass by value

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

323. Returning Values Use return to return a value from a subroutine sub exterminate { if (rand > .25) { print "Ex-Ter-Min-Ate $_[0]\n"; $timelords--; return 1; } else { return; } }

324. Returning a List Returning a list from a subroutine sub exterminate { my @exterminated; foreach (@_) { if (rand > .25) { print "Ex-Ter-Min-Ate $_\n"; $timelords--; push @exterminated, $_; } } return @exterminated; }

325. Regular Expressions

326. Regular Expressions Patterns that match strings

327. A bit like wild-cards

328. A "mini-language" within Perl Alien DNA The key to Perl's text processing power

329. Sometimes overused!

330. Documented in perldoc perlre

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

332. Works on $_ by default

333. In scalar context returns true if the match succeeds

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

335. m is optional if you use / characters

336. With m you can use any delimiters

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

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

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

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

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

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

346. Metacharacters Matching something other than literal text

347. ^ - matches start of string

348. $ - matches end of string

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

350. \s - matches a whitespace character

351. \S - matches a non-whitespace character

352. More Metacharacters \d - matches any digit

353. \D - matches any non-digit

354. \w - matches any "word" character

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

356. \b - matches a word boundary

357. \B - matches anywhere except a word boundary

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

359. Quantifiers Specify the number of occurrences

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

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

367. Character Classes Define a class of characters to match

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

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

374. /rose|martha|donna/i;

375. Use parentheses for grouping

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

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

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

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

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

381. More Information perldoc perlre

382. perldoc perlretut

383. Mastering Regular Expressions – Jeffrey Freidl

384. References

385. Introducing References A reference is a bit like pointer in languages like C and Pascal (but better)

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)

389. Creating References Put \ in front of a variable name $scalar_ref = \$scalar; $array_ref = \@array; $hash_ref = \%hash;

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

391. Creating References [ LIST ] creates anonymous array and returns a reference $aref = [ 'this', 'is', 'a', 'list']; $aref2 = [ @array ];

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

393. Creating References @arr = (1, 2, 3, 4); $aref1 = \@arr; $aref2 = [ @arr ]; print "$aref1\n$aref2\n"; Output ARRAY(0x20026800) ARRAY(0x2002bc00)

394. Second method creates a copy of the array

395. Using Array References Use {$aref} to get back an array that you have a reference to

396. Whole array

397. @array = @{$aref};

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

399. Single elements

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

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

402. Using Hash References Use {$href} to get back a hash that you have a reference to

403. Whole hash

404. %hash = %{$href};

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

406. Single elements

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

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

409. Using References Use arrow ( -> ) to access elements of arrays or hashes

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

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

412. Using References You can find out what a reference is referring to using ref

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

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

415. Why Use References? Parameter parsing

416. Complex data structures

417. Parameter Passing What does this do?

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

419. Why Doesn't It Work? Arrays are combined in @_

420. All elements end up in @a1

421. How do we fix it?

422. Pass references to the arrays

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

424. Complex Data Structures Another good use for references

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

429. Complex Data Structures 2D Array using references

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

434. Complex Data Structures Another 2D Array

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]

440. More Data Structures Imagine the following data file

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

446. More Data Structures Building an 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 "$_->{f_name} ", "$_->{s_name} ". "is a $_->{job}\n"; }

449. Complex Data Structures Many more possibilities Hash of hashes

450. Hash of lists

451. Multiple levels (list of hash of hash, etc.) Lots of examples in “ perldoc perldsc” (the data structures cookbook)

452. Smart Matching

453. Smart Matching Introduced in Perl 5.10

454. Powerful matching operator

455. DWIM

456. Examines operands

457. Decides which match to apply

458. Smart Match Operator ~~

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/

465. Smarter Matching If one of its operands is a 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

472. More Smart Matches @array1 ~~ @array2

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

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

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

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

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

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

489. http://search.cpan.org

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

491. Search by: module name

492. distribution name

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

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

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

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

497. You can have your own personal module library

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

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

500. CPANPLUS.pm is included with newer Perls

501. Automatically carries out installation process

502. Can also handle required modules

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

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

505. Or

506. cpanp -i Some::Module

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

508. Object modules usually don't

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

510. Using Functional Modules Import defaults: use My::Module;

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

514. Using Object Modules Use the module: use My::Object;

515. Create an object: $obj = My::Object->new; Note: new is just a convention Interact using object's methods $obj->set_name($name);

516. Useful Standard Modules constant

517. Time::Local

518. Text::ParseWords

519. Getopt::Std

520. Cwd

521. File::Basename File::Copy

522. POSIX

523. CGI

524. Carp

525. Benchmark

526. Data::Dumper

527. Useful Non-Standard Modules Template

528. DBI

529. DBIx::Class

530. DateTime

531. HTML::Parser

532. HTML::Tidy LWP

533. WWW::Mechanize

534. Email::Simple

535. XML::LibXML

536. XML::Feed

537. Moose

538. More Information

539. Perl Websites Perl Home Page http://www.perl.org CPAN http://www.cpan.org

540. http://search.cpan.org Perl Mongers (Perl User Groups)‏ http://www.pm.org

541. http://london.pm.org

542. Perl Websites use.perl – Perl News & Journals http://use.perl.org/ Perl Monks – Perl Help and Advice http://perlmonks.org/ Perl Documentation Online http://perldoc.perl.org/

543. Perl Conferences The Perl Conference (part of the Open Source Convention)‏ July 20-24 2009, San Jose, California

544. http://conferences.oreilly.com/oscon Yet Another Perl Conference August 3-5 2009, Lisbon, Portugal

545. http://www.yapceurope.org

546. Perl Conferences Other YAPCs Pittsburgh, Pennsylvania Brazil

547. Tokyo OSDC Israel

548. Australia

549. Perl Workshops One-day grassroots conferences

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

551. Perl Review Calendar www.theperlreview.com/community_calendar

552. Perl Mailing Lists See http://lists.perl.org for full details Perl Mongers (social discussion)‏

553. CGI

554. DBI

555. XML

556. Beginners

557. Advocacy

558. Fun with Perl

559. Perl Books Books for learning Perl Learning Perl (5th ed - June 2008) Schwartz, Phoenix & foy (O'Reilly)‏

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

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

562. Perl Books Books you should have access to Programming Perl (3rd edition) Wall, Christiansen & Orwant (O'Reilly)‏

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

566. Perl Books Books you should probably look at Mastering Regular Expressions Friedl (O'Reilly)‏

567. Data Munging with Perl Cross (Manning)‏

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

569. Perl Medic Scott (Addison Wesley)

570. Perl Books Specialised Perl books Object Oriented Perl Conway (Manning)‏

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

575. Perl Magazines The Perl Review http://www.theperlreview.com

576. That's All Folks Questions?

Beginning Perl

More Related Content

What's hot (20)

Viewers also liked (17)

Similar to Beginning Perl (20)

More from Dave Cross (20)

Recently uploaded (20)

Beginning Perl