• Like
Introduction to Perl
Upcoming SlideShare
Loading in...5
×

Introduction to Perl

  • 5,931 views
Uploaded on

Slides from the Introduction to Perl course, November 2009.

Slides from the Introduction to Perl course, November 2009.

More in: Technology , Business
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
5,931
On Slideshare
0
From Embeds
0
Number of Embeds
1

Actions

Shares
Downloads
491
Comments
0
Likes
10

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Introduction to Perl 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:45 – Begin
    • 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
  • 19. Resources
    • Slides available on-line
      • http://mag-sol.com/train/public/2009-11/ukuug
    • 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?
  • 39. The Perl Philosophy
    • There's more than one way to do it
    • 40. Three virtues of a programmer
    • 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
    • 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
  • 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
    • 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. Backslashes
    • Use a backslash to escape special characters in double quoted strings
    • 110. print "He said "The price is $300"";
    • 111. This can look ugly
  • 112. Better Quotes
    • This is a tidier alternative
    • 113. print qq(He said "The price is $300");
    • 114. Also works for single quotes
    • 115. print q(He said "That's too expensive");
  • 116. Undefined Values
    • A scalar variable that hasn't had data put into it will contain the special value “undef”
    • 117. Test for it with defined() function
    • 118. if (defined($my_var)) { ... }
  • 119. Array Variables
    • Arrays contain an ordered list of scalar values
    • 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);
  • 123. Array Elements
    • Accessing individual elements of an array
    • 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
  • 128. Array Slices
    • Returns a list of elements from an array
    • 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
  • 132. Setting Array Values
    • $array[4] = 'something';
    • 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];
    • 137. Doesn't need to be an array
      • ($x, $y) = ($y, $x);
  • 138. Array Size
    • $#array is the index of the last element in @array
    • 139. Therefore $#array + 1 is the number of elements
    • 140. $count = @array;
    • 141. Does the same thing and is easier to understand
  • 142. Hash Variables
    • Hashes implement “look-up tables” or “dictionaries”
    • 143. Initialised with a list
    • 144. %french = ('one', 'un', 'two', 'deux', 'three', 'trois');
  • 145. Fat Comma
    • The “fat comma” (=>) is easier to understand
    • 146. %german = (one => 'ein', two => 'zwei', three => 'drei');
  • 147. Accessing Hash Values
    • $three = $french{three};
    • 148. print $german{two};
    • 149. As with arrays, notice the use of $ to indicate that we're accessing a single value
  • 150. Hash Slices
    • Just like array slices
    • 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
  • 154. Setting Hash Values
    • $hash{foo} = 'something';
    • 155. $hash{bar} = 'something else';
    • 156. Also with slices
    • 157. @hash{'foo', 'bar'} = ('something', 'else');
    • 158. @hash{'foo', 'bar'} = @hash{'bar', 'foo'};
  • 159. More About Hashes
    • Hashes are not sorted
    • 160. There is no equivalent to $#array
    • 161. print %hash is unhelpful
    • 162. We'll see ways round these restrictions later
  • 163. Special Perl Variables
    • Perl has many special variables
    • 164. Many of them have punctuation marks as names
    • 165. Others have names in ALL_CAPS
    • 166. They are documented in perlvar
  • 167. The Default Variable
    • Many Perl operations either set $_ or use its value if no other is given
    • 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
  • 171. Using $_
    • while (<FILE>) { if (/regex/) { print; } }
    • 172. Three uses of $_
  • 173. A Special Array
    • @ARGV
    • 174. Contains your programs command line arguments
    • 175. my $num = @ARGV; print &quot;$num arguments: @ARGV &quot;;
    • 176. perl printargs.pl foo bar baz
  • 177. A Special Hash
    • %ENV
    • 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
  • 183. Input and Output
    • Programs become more useful with input and output
    • 184. We'll see more input and output methods later in the day
    • 185. But here are some simple methods
  • 186. Output
    • The easiest way to get data out of a Perl program is to use print
    • 187. print “Hello world ”;
  • 188. Input
    • The easiest way to get data into a Perl program is to read from STDIN
    • 189. $input = <STDIN>;
    • 190. < ... > is the “read from filehandle” operator
    • 191. STDIN is the standard input filehandle
  • 192. A Complete Example
    • #!/usr/bin/perl print 'What is your name: '; $name = <STDIN>; print “Hello $name”;
  • 193. Operators and Functions
  • 194. Operators and Functions
    • What are operators and functions?
    • 195. “Things” that do “stuff”
    • 196. Routines built into Perl to manipulate data
    • 197. Other languages have a strong distinction between operators and functions
      • in Perl that distinction can be a bit blurred
    • See perlop and perlfunc
  • 198. Arithmetic Operators
    • Standard arithmetic operations add (+), subtract (-), multiply (*), divide (/)‏
    • 199. Less standard operations modulus (%), exponentiation (**)‏
    • 200. $speed = $distance / $time;
    • 201. $vol = $length * $breadth * $height;
    • 202. $area = $pi * ($radius ** 2);
    • 203. $odd = $number % 2;
  • 204. Shortcut Operators
    • Often need to do things like
    • 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
  • 211. String Operators
    • Concaternation (.)
    • 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
  • 218. File Test Operators
    • Check various attributes of a file
    • 219. -e $file does the file exist
    • 220. -r $file is the file readable
    • 221. -w $file is the file writeable
  • 222. More File Test Operators
    • Check various attributes of a file
    • 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
  • 227. Functions
    • Have longer names than operators
    • 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
  • 231. Function Return Values
    • Functions can return scalars or lists (or nothing)‏
    • 232. $age = 29.75; $years = int($age);
    • 233. @list = ('a', 'random', 'collection', 'of', 'words'); @sorted = sort(@list); # a collection of random words
  • 234. String Functions
    • length returns the length of a string
    • 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
  • 239. More String Functions
    • chop removes the last character from a string and returns it
    • 240. $word = 'word'; $letter = chop $word;
    • 241. chomp removes the last character only if it is a newline and returns true or false appropriately
  • 242. Substrings
    • substr returns substrings from a string
    • 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'
  • 246. Numeric Functions
    • abs returns the absolute value
    • 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
  • 252. Array Manipulation
    • push adds a new element to the end of an array
    • 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
  • 257. Array Manipulation
    • sort returns a sorted list
      • it does not sort the list in place
    • @sorted = sort @array;
    • 258. sort does a lot more besides, see the docs (perldoc -f sort)‏
    • 259. reverse returns a reversed list
    • 260. @reverse = reverse @array;
  • 261. Arrays and Strings
    • join takes an array and returns a string
    • 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)‏
  • 265. Hash Functions
    • delete removes a key/value pair from a hash
    • 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
  • 269. File Operations
    • open opens a file and associates it with a filehandle
    • 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);
  • 276. Other File Functions
    • read to read a fixed number of bytes into a buffer
    • 277. $bytes = read(FILE, $buffer, 1024);
    • 278. seek to move to a random position in a file
    • 279. seek(FILE, 0, 0);
  • 280. Other File Functions
    • tell to get current file position
    • 281. $where = tell FILE;
    • 282. truncate to truncate file to given size
    • 283. truncate FILE, $where;
  • 284. Writing to Files
    • Open file in write mode
    • 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
  • 290. Time Functions
    • time returns the number of seconds since midnight Jan 1st 1970
    • 291. $now = time;
    • 292. localtime converts that into more usable values
    • 293. ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) = localtime($now);
  • 294. localtime Caveats
    • $mon is 0 to 11
    • 295. $year is years since 1900
    • 296. $wday is 0 (Sun) to 6 (Sat)‏
  • 297. localtime Shortcuts
    • It's common to use localtime on the current time
    • 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];
  • 303. Date & Time Formats
    • You can get formatted dates by fiddling the return values from localtime
    • 304. Easier to use strftime (from POSIX.pm)
    • 305. use POSIX 'strftime';
    • 306. print strftime('%Y-%m-%d', localtime);
  • 307. Date & Time Formats
    • Format followed by list of date/time values
    • 308. Format is POSIX standard
      • Like UNIX date command
    • print strftime('%d %B %y', localtime);
    • 309. print strftime('%H:%M:%S', localtime);
  • 310. Conditional Constructs
  • 311. Conditional Constructs
    • Conditional constructs allow us to choose different routes of execution through the program
    • 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 { … }
  • 315. Conditional Constructs
    • Conditional blocks are controlled by the evaluation of an expression to see if it is true or false
    • 316. But what is truth?
  • 317. What is Truth?
    • In Perl it's easier to answer the question &quot;what is false?&quot;
    • 318. 0 (the number zero)‏
    • 319. '' (the empty string)‏
    • 320. undef (an undefined value)‏
    • 321. () (an empty list)‏
    • 322. Everything else is true
  • 323. Comparison Operators
    • Compare two values in some way
    • 324. Are they equal
      • $x == $y or $x eq $y
      • 325. $x != $y or $x ne $y
    • Is one greater than another
      • $x > $y or $x gt $y
      • 326. $x >= $y or $x ge $y
  • 327. Comparison Operators
    • Is one less than another
      • $x < $y or $x lt $y
      • 328. $x <= $y or $x le $y
  • 329. Comparison Examples
    • 62 > 42 # true
    • 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
  • 335. Boolean Operators
    • Combine conditional expressions
    • 336. 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
    • 337. Different precedence though
  • 338. Short-Circuit Operators
    • EXPR_1 or EXPR_2
    • 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;
  • 343. if
    • if - our first conditional
    • 344. if (EXPR) { BLOCK }
    • 345. Only executes BLOCK if EXPR is true
    • 346. if ($name eq 'Doctor') { regenerate(); }
  • 347. if ... else ...
    • if … else ... - an extended if
    • 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;; }
  • 351. if ... elsif ... else ...
    • if … elsif … else … - even more control
    • 352. if (EXPR1) { BLOCK1 } elsif (EXPR2) { BLOCK2 } else { BLOCK3 }
  • 353. if ... elsif ... else ...
    • If EXPR1 is true, execute BLOCK1 else if EXPR2 is true, execute BLOCK2 otherwise execute BLOCK3
  • 354. if ... elsif ... else ...
    • An example
    • 355. if ($name eq 'Doctor') { regenerate(); } elsif ($tardis_location eq $here) { escape(); } else { die &quot;Game over! &quot;; }
  • 356. while
    • while - repeat the same code
    • 357. while (EXPR) { BLOCK }
    • 358. Repeat BLOCK while EXPR is true
    • 359. while ($dalek_prisoners) { print &quot;Ex-ter-min-ate &quot;; $dalek_prisoners--; }
  • 360. until
    • until - the opposite of while
    • 361. until (EXPR) { BLOCK }
    • 362. Execute BLOCK until EXPR is true
    • 363. until ($regenerations == 12) { print &quot;Regenerating &quot;; regenerate(); $regenerations++; }
  • 364. for
    • for - more complex loops
    • 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
  • 368. for
    • An example
    • 369. for ($i = 1; $i <= 10; $i++) { print &quot;$i squared is &quot;, $i * $i, &quot; &quot;; }
    • 370. Used surprisingly rarely
  • 371. foreach
    • foreach - simpler looping over lists
    • 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;; }
  • 375. foreach
    • Another example
    • 376. my %months = (Jan => 31, Feb => 28, Mar => 31, Apr => 30, May => 31, Jun => 30, … ); foreach (keys %months) { print &quot;$_ has $months{$_} days &quot;; }
  • 377. Using while Loops
    • Taking input from STDIN
    • 378. while (<STDIN>) { print; }
    • 379. This is the same as
    • 380. while (defined($_ = <STDIN>)) { print $_; }
  • 381. Breaking Out of Loops
    • next – jump to next iteration of loop
    • 382. last – jump out of loop
    • 383. redo – jump to start of same iteration of loop
  • 384. Subroutines
  • 385. Subroutines
    • Self-contained &quot;mini-programs&quot; within your program
    • 386. Make it easy to repeat code
    • 387. Subroutines have a name and a block of code
    • 388. sub NAME { BLOCK }
  • 389. Subroutine Example
    • sub exterminate { print &quot;Ex-Ter-Min-Ate!! &quot;; $timelords--; }
  • 390. Calling a Subroutine
    • &exterminate;
    • 391. exterminate();
    • 392. exterminate;
    • 393. last one only works if function has been predeclared
  • 394. Subroutine Arguments
    • Functions become far more useful if you can pass arguments to them
    • 395. exterminate('The Doctor');
    • 396. Arguments end up in the @_ array within the function
  • 397. Subroutine Arguments
    • sub exterminate { my ($name) = @_; print &quot;Ex-Ter-Min-Ate $name &quot;; $timelords--; }
  • 398. Multiple Arguments
    • As @_ is an array it can contain multiple arguments
    • 399. sub exterminate { foreach (@_) { print &quot;Ex-Ter-Min-Ate $_ &quot;; $timelords--; } }
  • 400. Calling Subroutines
    • A subtle difference between &my_sub and my_sub()‏
    • 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
  • 404. 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
    • 405. Passing by reference passes the actual variable. Changing the argument alters the external value
    • 406. Perl allows you to choose
  • 407. Pass By Value
    • Simulating pass by value
    • 408. my ($arg1, $arg2) = @_;
    • 409. Updating $arg1 and $arg2 doesn’t effect anything outside the subroutine
  • 410. Pass By Reference
    • Simulating pass by reference
    • 411. $_[0] = 'whatever';
    • 412. Updating the contents of @_ updates the external values
  • 413. Returning Values
    • Use return to return a value from a subroutine
    • 414. sub exterminate { if (rand > .25) { print &quot;Ex-Ter-Min-Ate $_[0] &quot;; $timelords--; return 1; } else { return; } }
  • 415. Returning a List
    • Subroutines can return lists
    • 416. sub exterminate { my @exterminated; foreach (@_) { if (rand > .25) { print &quot;Ex-Ter-Min-Ate $_ &quot;; $timelords--; push @exterminated, $_; } } return @exterminated; }
  • 417. Regular Expressions
  • 418. Regular Expressions
    • Patterns that match strings
    • 419. A bit like wild-cards
    • 420. A “mini-language” within Perl
      • Alien DNA
    • The key to Perl's text processing power
    • 421. Sometimes overused!
    • 422. Documented in perldoc perlre
  • 423. Match Operator
    • m/PATTERN/ - the match operator
    • 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
  • 429. Match Examples
    • while (<FILE>) { print if /foo/; print if /bar/i; print if m|http://|; }
  • 430. Substitutions
    • s/PATTERN/REPLACEMENT/ - the substitution operator
    • 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
  • 435. Substitution Examples
    • while (<FILE>) { s/teh/the/gi; s/freind/friend/gi; s/sholud/should/gi; print; }
  • 436. Binding Operator
    • If we want m// or s/// to work on something other than $_ then we need to use the binding operator
    • 437. $name =~ s/Dave/David/;
  • 438. Metacharacters
    • Matching something other than literal text
    • 439. ^ - matches start of string
    • 440. $ - matches end of string
    • 441. . - matches any character (except )‏
    • 442. s - matches a whitespace character
    • 443. S - matches a non-whitespace character
  • 444. More Metacharacters
    • d - matches any digit
    • 445. D - matches any non-digit
    • 446. w - matches any &quot;word&quot; character
    • 447. W - matches any &quot;non-word&quot; character
    • 448.  - matches a word boundary
    • 449. B - matches anywhere except a word boundary
  • 450. Metacharacter Examples
    • while (<FILE>) { print if m|^http|; print if /perl/; print if /S/; print if /$d.dd/; }
  • 451. Quantifiers
    • Specify the number of occurrences
    • 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
  • 458. Quantifier Examples
    • while (<FILE>) { print if /whiske?y/i; print if /so+n/; print if /d*.d+/; print if /Aw{3}/; }
  • 459. Character Classes
    • Define a class of characters to match
    • 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
  • 465. Alternation
    • Use | to match one of a set of options
    • 466. /rose|martha|donna/i;
    • 467. Use parentheses for grouping
    • 468. /^(rose|martha|donna)$/i;
  • 469. Capturing Matches
    • Parentheses are also used to capture parts of the matched string
    • 470. The captured parts are in $1 , $2 , etc…
    • 471. while (<FILE>) { if (/^(w+)s+(w+)/) { print &quot;The first word was $1 &quot;; print &quot;The second word was $2&quot;; } }
  • 472. Returning Captures
    • Captured values are also returned if the match operator is used in list context
    • 473. my @nums = $text =~ /(d+)/g; print &quot;I found these integers: &quot;; print &quot;@nums &quot;;
  • 474. More Information
    • perldoc perlre
    • 475. perldoc perlretut
    • 476. Mastering Regular Expressions – Jeffrey Freidl
  • 477. Smart Matching
  • 478. Smart Matching
    • Introduced in Perl 5.10
    • 479. Powerful matching operator
    • 480. DWIM
    • 481. Examines operands
    • 482. Decides which match to apply
  • 483. Smart Match Operator
    • ~~
    • 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/
  • 490. Smarter Matching
    • If one of its operands is a 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
  • 497. More Smart Matches
    • @array1 ~~ @array2
    • 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
  • 503. Smart Scalar Matches
  • 510. Finding and Using Modules
  • 511. Modules
    • A module is a reusuable 'chunk' of code
    • 512. Perl comes with over 100 modules (see “perldoc perlmodlib” for list)
    • 513. Perl has a repository of freely-available modules - the Comprehensive Perl Archive Network (CPAN)
      • http://www.cpan.org
      • 514. http://search.cpan.org
  • 515. Finding Modules
    • http://search.cpan.org
    • 516. Search by:
    • Note: CPAN also contains newer versions of standard modules
  • 519. 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
  • 520. Installing Modules (The Hard Way)
    • Create Makefile
      • $ perl Makefile.PL
    • Build Module
      • $ make
    • Test Build
      • $ make test
    • Install Module
      • $ make install
  • 521. Installing Modules (The Hard Way)
    • Note: May need root permissions for make install
    • 522. You can have your own personal module library
    • 523. perl Makefile.PL PREFIX=~/perl
      • need to adjust @INC
  • 524. Installing Modules (The Easy Way)
    • CPANPLUS.pm is included with newer Perls
    • 525. Automatically carries out installation process
    • 526. Can also handle required modules
  • 527. Installing Modules (The Easy Way)
    • May not work (or may need some configuration) through a firewall
    • 528. May still need to be root
      • Can use 'sudo'
  • 529. Installing Modules (The Easy Way)
    • cpanp [ ... some stuff ... ] CPAN Terminal> install Some::Module [ ... some more stuff ... ] CPAN Terminal> quit
    • 530. Or
    • 531. cpanp -i Some::Module
  • 532. Using Modules
    • Two types of module:
      • Functions vs Objects
    • Functional modules export new subroutines and variables into your program
    • 533. Object modules usually don't
    • 534. Difference not clear cut (e.g. CGI.pm)
  • 535. Using Functional Modules
    • Import defaults:
    • 536. use My::Module;
    • 537. Import optional components:
    • 538. use My::Module qw(my_sub @my_arr);
  • 539. Using Functional Modules
    • Import defined sets of components:
    • 540. use My:Module qw(:advanced);
    • 541. Use imported components:
    • 542. $data = my_sub(@my_arr);
  • 543. Using Object Modules
    • Use the module:
    • 544. use My::Object;
    • 545. Create an object:
    • 546. $obj = My::Object->new;
      • Note: new is just a convention
    • Interact using object's methods
    • 547. $obj->set_name($name);
  • 548. Useful Standard Modules
  • 559. Useful Non-Standard Modules
  • 570. That's All Folks
    • Any Questions?