Introduction to Perl - Day 1
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Introduction to Perl - Day 1

on

  • 75,246 views

Day 1 of the "Introducing Perl" training course that I ran at YAPC::Europe in Lisbon in August 2009.

Day 1 of the "Introducing Perl" training course that I ran at YAPC::Europe in Lisbon in August 2009.

Statistics

Views

Total Views
75,246
Views on SlideShare
74,832
Embed Views
414

Actions

Likes
29
Downloads
2,725
Comments
5

13 Embeds 414

http://www.slideshare.net 324
http://sumariolinux.blogspot.com 64
http://sigma 5
http://sumariolinux.blogspot.mx 4
http://sumariolinux.blogspot.com.es 3
http://meri-sapnon-ki-duniya.blogspot.com 3
http://translate.googleusercontent.com 3
http://www.linkedin.com 2
https://www.linkedin.com 2
http://www.e-presentations.us 1
http://meri-sapnon-ki-duniya.blogspot.in 1
http://slideclip.b-prep.com 1
http://e-presentations.us 1
More...

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • oww
    Are you sure you want to
    Your message goes here
    Processing…
  • super
    Are you sure you want to
    Your message goes here
    Processing…
  • EXCELLENT
    Are you sure you want to
    Your message goes here
    Processing…
  • Great presentation, especially the images were very well chosen.
    http://www.worldbiznews.net
    http://www.worldbiznews.net/category/banking-news/
    http://www.worldbiznews.net/category/bankruptcy/
    Are you sure you want to
    Your message goes here
    Processing…
  • Attended the 2 day course in Lisbon, and it was a very good and comprehensive introduction. Dave is a very good speaker and knows his stuff.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Introduction to Perl - Day 1 Presentation Transcript

  • 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 ";
    • 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! "; # 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.' ";
  • 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 ";
    • 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 &quot;$num arguments: @ARGV &quot;;
    • 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 ”;
  • 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 &quot;$string &quot;, uc $string, &quot; &quot;, 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 ”;
    • 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 &quot;what is false?&quot;
      • 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 &quot;Can't open file: $!&quot;;
    • 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 &quot;Game over! &quot;; }
  • 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 &quot;Game over! &quot;; }
  • 349. while
    • while - repeat the same code
    • 350. while (EXPR) { BLOCK }
    • 351. Repeat BLOCK while EXPR is true
    • 352. while ($dalek_prisoners) { print &quot;Ex-ter-min-ate &quot;; $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 &quot;Regenerating &quot;; 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 &quot;$i squared is &quot;, $i * $i, &quot; &quot;; }
    • 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 &quot;$i squared is &quot;, $i * $i, &quot; &quot;; }
  • 368. foreach
    • Another example
    • 369. my %months = (Jan => 31, Feb => 28, Mar => 31, Apr => 30, May => 31, Jun => 30, … ); foreach (keys %months) { print &quot;$_ has $months{$_} days &quot;; }
  • 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 &quot;mini-programs&quot; 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 &quot;Ex-Ter-Min-Ate!! &quot;; $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 &quot;Ex-Ter-Min-Ate $name &quot;; $timelords--; }
  • 391. Multiple Arguments
    • As @_ is an array it can contain multiple arguments
    • 392. sub exterminate { foreach (@_) { print &quot;Ex-Ter-Min-Ate $_ &quot;; $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 &quot;Ex-Ter-Min-Ate $_[0] &quot;; $timelords--; return 1; } else { return; } }
  • 408. Returning a List
    • Subroutines can return lists
    • 409. sub exterminate { my @exterminated; foreach (@_) { if (rand > .25) { print &quot;Ex-Ter-Min-Ate $_ &quot;; $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 &quot;captured&quot; 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 )‏
    • 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 &quot;word&quot; character
    • 440. W - matches any &quot;non-word&quot; character
    • 441.  - matches a word boundary
    • 442. B - matches anywhere except a word boundary
  • 443. Metacharacter Examples
    • while (<FILE>) { print if m|^http|; print if /perl/; print if /S/; print if /$d.dd/; }
  • 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 /Aw{3}/; }
  • 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 &quot;The first word was $1 &quot;; print &quot;The second word was $2&quot;; } }
  • 465. Returning Captures
    • Captured values are also returned if the match operator is used in list context
    • 466. my @nums = $text =~ /(d+)/g; print &quot;I found these integers: &quot;; print &quot;@nums &quot;;
  • 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