Just Another Perl Article

• Getting a Handle on Files
• "Open, Sesame!"
  • Obfuscorner
• Whose Line Is It, Anyway?
• Outputting Records
  • While We're Being Lazy...
  • Huffering, Puffering, and Buffering
  • Obfuscorner
• The Magic of <>
  • Lazy Loops
• References

# error-checking would, of course, be used

open FILE, "filename";      # read
open FILE, "< filename";    # read (explicit)
open FILE, "> filename";    # overwrite
open FILE, ">> filename";   # append
open FILE, "+< filename";   # read and write
open FILE, "+> filename";   # read and overwrite (clobber first)
open FILE, "+>> filename";  # read and append
open FILE, "program |";     # read from program
open FILE, "| program";     # write to program

chomp(my $filename = <STDIN>);
open FILE, $filename;

# open FILEHANDLE, MODE, EXPR

open FILE, "<", $filename;  # read from $filename

# open FILEHANDLE, MODE, EXPR, LIST

open LS, "-|", "ls", "-R";

for my $f (@listing) {
  open my($fh), "<", $f;
  push @files, $fh;
}

open 0;  # like:  open 0, $0

open FORTUNE, "< /usr/share/games/fortunes/art";
{
  local $/ = "\n%\n";
  @fortunes = <FORTUNE>;
}
close FORTUNE;

• Setting $/ to "" causes Perl to use "paragraph" mode; it will read a chunk of lines that is followed by extra newlines -- in other words, a sequence of bytes ending in two or more newlines.
• Setting $/ to undef causes Perl to read the rest of the file all at once.

while (read(FILE, $buf, 1024)) { ... }

# is like

{
  local $/ = \1024;
  while ($buf = <FILE>) { ... }
}

• $\ goes where you put a \n in your print()
• $, goes where you put a , in your print()

open PASSWD, "/etc/passwd"
  or die "can't read /etc/passwd: $!";
open MOD, "> /etc/weirdpasswd"
  or die "can't write to /etc/weirdpasswd: $!";

$\ = $/;   # ORS = IRS = "\n"
$, = ":";  # OFS = ","

while (<PASSWD>) {
  chomp;  # removes $/ from $_
  my @f = split $,;  # splits $_ on occurrences of $,
  # fool around with @f
  print MOD @f;
}

close MOD;
close PASSWD;

while (<PASSWD>) {
  chomp;
  my @f = split ':';
  # fool around with @f
  print MOD join(':', @f), "\n";
}

for my $line (@lines) {
  chomp $line;
  my @fields = split /=/, $line;
  for my $f (@fields) { $f =~ s/->/: /; }
  # ...
}

for (@lines) {
  chomp;
  my @fields = split /=/;
  for (@fields) { s/->/:/ }
  # ...
}

print "to stdout\n";
my $oldfh = select MOD;
print "to mod\n";
select $oldfh;
print "to stdout\n";

# turn on autoflushing for OUT
{
  my $old = select OUT;
  $| = 1;
  select $old;
}

# another way, using IO::Handle
use IO::Handle;
autoflush OUT 1;

select((select(OUT), $|=1)[0]);

# alternate indenting and not indenting lines
for (@data) {
  print "  " x $|--;
  print "$_\n";
}

#!/usr/bin/perl -w

# inplace.pl ext code [files]
# ex: inplace.pl .bak '$_ = "" if /^#/' *.pl

use strict;

$^I = shift;
my $code = shift;

while (<>) {
  eval $code;
  print;
}

• @ARGV
  • the list of command-line arguments to your program
  • when using <>, Perl uses these arguments as sources of input (so you can read from "ls |"!)
  • if the array is empty to begin with, Perl puts "-" in there, which means "read from STDIN"
  • when a file is being read, it is removed (shift()ed) from the array
• $ARGV
  • this holds the input source currently begin read from
• ARGV
  • this is the filehandle opened, using $ARGV
• ARGVOUT
  • if $^I is not undef, this is the output filehandle being printed to
  • it is select()ed automatically
• $^I
  • this is the in-place editing backup extension variable, and can be set from the command-line via the -i switch
  • if this isn't undef, the loop will read from ARGV and write to ARGVOUT
  • if it contains the "*" character, the value is not an extension, but the new name of the file (so if modifying foo.txt and $^I is "old-*", the backup file is old-foo.txt)

#!/usr/bin/perl -w

use strict;

my $ext = shift;
my $code = shift;

@ARGV = '-' unless @ARGV;

FILE:
while (defined($ARGV = shift)) {
  my $backup;

  # if we're not working with STDIN...
  if ($ARGV ne '-') {
    # get backup filename
    if ($ext =~ /\*/) { ($backup = $ext) =~ s/\*/$ARGV/ }
    else { $backup = "$ARGV$ext" }

    # try renaming file
    rename $ARGV => $backup or
      warn("Can't rename $ARGV to $backup: $!, skipping file.") and
      next FILE;
  }

  # with STDIN, there's no real backup done
  else { $backup = '-' }

  open ARGV, "< $backup" or
    warn("Can't open $backup: $!") and
    next FILE;

  # if we're not dealing with STDIN,
  # but $backup is $ARGV, we're doing real
  # in-place editing, so we use a Unix trick:
  #   * open the file for reading
  #   * unlink it
  #   * open the file for writing
  # this is a miracle, but it fails in DOS :(

  if ($backup ne '-' and $backup eq $ARGV) {
    unlink $backup or
      warn("Can't remove $backup: $!, skipping file.") and
      next FILE;
  }

  open ARGVOUT, "> $ARGV" or
    warn("(panic) Can't write $ARGV: $!, skipping file.") and
    next FILE;

  while (<ARGV>) {
    eval $code;
    print ARGVOUT;
  }

  close ARGVOUT;
  # note: we don't close ARGV!
}

while (<>) {
  print "$ARGV ($.): $_";
}

a.txt (1): abc
a.txt (2): def
a.txt (3): ghi
b.txt (4): jkl
b.txt (5): mno

while (<>) {
  print "$ARGV ($.): $_";
  close ARGV if eof;  # reset $.
}

# or

while (<>) {
  print "$ARGV ($.): $_";
  close ARGV if eof(ARGV);  # reset $.
}

while (<>) {
  print "$ARGV ($.): $_";
  print "==end==\n" if eof();  # after ALL data
}

perl -ne 'print if /foo/' files
# becomes
perl -e 'while (<>) { print if /foo/ }' files

perl -pe 's/foo/bar/' files
# becomes
perl -e 'while (<>) { s/foo/bar/ } continue { print }' files

# keep backups
perl -pi.bak -e 's/PERL/Perl/g' files

# don't keep backups
perl -pi -e 's/PERL/Perl/g' files

• open(): perldoc -f open
• close(): perldoc -f close
• select(): perldoc -f select
• eof(): perldoc -f eof
• overview: perldoc perlopentut

• $/, $\, $|, $,, $.: perldoc perlvar
• chomp(): perldoc -f chomp
• the IO::Handle module: perldoc IO::Handle

• the -i, -n, and -p switches: perldoc perlrun