Perl File handles, Operators, and Regular Expression

Filehandles

• Filehandles are similar to streams
• Use the open function to create a filehandle and attach it to a file

  open(SESAME, "filename"); # read from existing file open(SESAME, "<filename"); # (same thing, explicitly) open(SESAME, ">filename"); # create file and write to it open(SESAME, ">>filename"); # append to existing file open(SESAME, "| output-pipe-command"); # set up an output filter open(SESAME, "input-pipe-command |"); # set up an input filter

• The angle operator encloses the filehandle you want to read lines from

  print STDOUT "Enter a number: "; # ask for a number $number = <STDIN>; # input the number print STDOUT "The number is $number\n"; # print the number

  • The empty angle operator, <>, reads lines from all the files specified on the command line, or STDIN, if none were specified
• read does not automatically remove the newline from its input line

  chop($number = <STDIN>); # input number and remove newline

Operators

• Some binary operators

  Binary Arithmetic Operators

  Example	Name	Result
  $a + $b	Addition	Sum of $a and $b
  $a * $b	Multiplication	Product of $a and $b
  $a % $b	Modulus	Remainder of $a divided by $b
  $a ** $b	Exponentiation	$a to the power of $b

• String operators

  $a = 123; $b = 456; $c = 3; print $a + $b; # prints 579 print $a . $b; # prints 123456 $b = 3; print $a * $c; # prints 369 print $a x $c; # prints 123123123

• Assignment Operators
• Autoincrement and Autodecrement Operators
• Logical Operators
• Comparison Operators
• File Test Operators

  Some File Test Operators

  Example	Name	Result
  -e $a	ExistsTrue if file named in $a exists
  -r $a	ReadableTrue if file named in $a is readable
  -w $a	WritableTrue if file named in $a is writable
  -d $a	DirectoryTrue if file named in $a is a directory
  -f $a	FileTrue if file named in $a is a regular file
  -T $a	Text FileTrue if file named in $a is a text file

• Examples

  -e "/usr/bin/perl" or warn "Perl is improperly installed\n"; -f "/vmunix" and print "Congrats, we seem to be running BSD Unix\n";

Control Structures

• What Is Truth?
  • Any string is true except for "" and "0"
  • Any number is true except for 0
    • Any reference is true.
    • Any undefined value is false

  0 # would become the string "0", so false 1 # would become the string "1", so true 10 - 10 # 10-10 is 0, would convert to string "0", so false 0.00 # becomes 0, would convert to string "0", so false "0" # the string "0", so false "" # a null string, so false "0.00" # the string "0.00", neither empty nor exactly "0", so true "0.00" + 0 # the number 0 (coerced by the +), so false. \$a # a reference to $a, so true, even if $a is false undef() # a function returning the undefined value, so false

Control Structures

• The if, else, elsif and unless statements

  unless ($destination eq $home) { print "I'm not going home.\n"; }

  • There is no "elsunless" though
• Iterative (Looping) Constructs
  • The while and until statements
  • The for statement
  • The foreach statement
  • Breaking out: next and last

    foreach $user (@users) { if ($user eq "root" or $user eq "lp") { next; } if ($user eq "special") { print "Found the special account.\n"; # do some processing last; } }

Regular Expressions

• The simplest use of regular expressions is to match a literal expression

  while ($line = <FILE>) { if ($line =~ /http:/) { print $line; } }

• The special variable $_

  while (<FILE>) { print if /http:/; print if /ftp:/; print if /mailto:/; # What next? }

Regular Expressions

• Quantifiers - placed after the item being quantified
  • Match at least seven digits, but no more than eleven digits

    /\d{7,11}/

• Minimal Matching - use of a question mark after any quantifier
  • Stops at the first colon rather than the last

    /.*?:/

• Nailing Things Down - matching a special kind of "nothing" that depends on its surroundings
  • \b matches at a word boundary
  • Matches "Fred the Great" but not "Frederick the Great":

    /\bFred\b/

  • Go to the next iteration of LINE loop if this line begins with #

    next LINE if $line =~ /^#/;

• Backreferences - use parentheses to remember bits and pieces of what you matched
  • Swap the first two words of a string

    s/(\S+)\s+(\S+)/$2 $1/

Regular Expressions Examples

• Examples:

  s/^([^ ]+) +([^ ]+)/$2 $1/; # swap first two words /(\w+)\s*=\s*\1/; # match "foo = foo" /.{80,}/; # match line of at least 80 chars /^(\d+\.?\d*|\.\d+)$/; # match valid number

• Pull fields out of a line

  if (/Time: (..):(..):(..)/) { $hours = $1; $minutes = $2; $seconds = $3; }

• Pull a substring out of a line

  if (/Version: *([0-9.]+)/) { $version = $1; }

Matching Operator

• m/PATTERN/gimosx

  This operator searches a string for a pattern match, and in a scalar context returns true (1) or false (""). If no string is specified via the =~ or !~ operator, the $_ string is searched.
• Modifiers are:

  Modifier	Meaning
  g	Match globally, that is, find all occurrences.
  i	Do case-insensitive pattern matching.
  m	Treat string as multiple lines. (continued)
  o	Only compile pattern once.
  s	Treat string as single line.
  x	Use extended regular expressions.

• Use any pair of non-alphanumeric, non-whitespace characters as delimiters. This is particularly useful for matching filenames that contain "/"
• If used in a context that requires a list value, a pattern match returns a list consisting of the subexpressions matched by the parentheses in the pattern - that is, ($1, $2, $3 ...).

Examples

• case insensitive matching

  open(TTY, '/dev/tty'); <TTY> =~ /^y/i and foo(); # do foo() if they want it

• pulling a substring out of a line

  if (/Version: *([0-9.]+)/) { $version = $1; }

• avoiding Leaning Toothpick Syndrome

  next if m#^/usr/spool/uucp#;

• poor man's grep

  $arg = shift; while (<>) { print if /$arg/o; # compile only once }

• get first two words and remainder as a list

  if (($F1, $F2, $Etc) = ($foo =~ /^\s*(\S+)\s+(\S+)\s*(.*)/))

• This last example splits $foo into the first two words and the remainder of the line, and assigns those three fields to $F1, $F2, and $Etc. The conditional is true if any variables were assigned, that is, if the pattern matched. Usually, though, one would just write the equivalent split:

  if (($F1, $F2, $Etc) = split(' ', $foo, 3))

Substitution Operator

• s/PATTERN/REPLACEMENT/egimosx

  This operator searches a string for PATTERN, and if found, replaces that match with the REPLACEMENT text and returns the number of substitutions made, which can be more than one with the /g modifier. Otherwise it returns false (0).
• Modifiers are:

  Modifier	Meaning
  e	Evaluate the right side as an expression.
  g	Replace globally, that is, all occurrences.
  i	Do case-insensitive pattern matching.
  m	Treat string as multiple lines. (continued)
  o	Only compile pattern once.
  s	Treat string as single line.
  x	Use extended regular expressions.

Examples

• don't change wintergreen

  s/\bgreen\b/mauve/g;

• avoid LTS with different quote characters

  $path =~ s(/usr/bin)(/usr/local/bin);

• interpolated pattern and replacement

  s/Login: $foo/Login: $bar/;

• modifying a string "en passant"

  ($foo = $bar) =~ s/this/that/;

• counting the changes

  $count = ($paragraph =~ s/Mister\b/Mr./g);

• using an expression for the replacement

  $_ = 'abc123xyz'; s/\d+/$&*2/e; # yields 'abc246xyz' s/\d+/sprintf("%5d",$&)/e; # yields 'abc 246xyz' s/\w/$& x 2/eg; # yields 'aabbcc 224466xxyyzz'

• how to default things with /e

  s/%(.)/$percent{$1}/g; # change percent escapes; no /e s/%(.)/$percent{$1} || $&/ge; # expr now, so /e s/^=(\w+)/&pod($1)/ge; # use function call # /e's can even nest; this will expand simple embedded variables in $_ s/(\$\w+)/$1/eeg;

• delete C comments

  $program =~ s { /\* # Match the opening delimiter. .*? # Match a minimal number of characters. \*/ # Match the closing delimiter. } []gsx;

• trim white space

  s/^\s*(.*?)\s*$/$1/;

• reverse 1st two fields

  s/([^ ]*) *([^ ]*)/$2 $1/;

  Note the use of $ instead of \ in the last example.

List Processing

• The list on the right side contains exactly four values:

  @array = (1 + 2, 3 - 4, 5 * 6, 7 / 8);

• Some operators can produce either a scalar or a list value, depending on their context

  sort @guys, @gals, other();

  • Each of the LIST elements produces its list in turn, then
  • all the separate lists are joined together, end to end, into a single list.
  • The one-dimensional list is handed off to the function that wanted a LIST in the first place - sort
• Filters and such

  print reverse sort map {lc} keys %hash;

  • Takes the keys of %hash and returns them to the map function, which
  • lowercases all the keys by applying the lc operator to each of them, and passes them to the sort function, which
  • sorts them, and passes them to the reverse function, which
  • reverses the order of the list elements, and passes them to the print function, which prints them.