Perl: Just The Bullets Ma'am

• Arrays
• Hashes
• Refs
• Modules
• Vernacular
• Fragments
• Filter Template
• Useful Tables
• Bibliography

Arrays

• initial notation is my @array;.
• creating: @array = (1,2,3);.
• reference is $array[$index] NOTE– the leading $, this is a scalar reference!
• assignment is $array[$index] = $value;.
• size of an array is print "array size = ",scalar(@array),"\n"; or print "array size = ".($#array + 1)."\n"; or $length = @array; print "array size = $length\n";.
• access to a portion or portions of an array is called a slice. Given an array– @foo = (10,12,14,16) then:
  • @bar = @foo[1,2]; # @bar gets the list (12,14)
  • @bar = @foo[3,0,1]; # @bar gets the list (16,10,12)
  • @bar = @foo[1..3]; # @bar gets the list (12,14,16)
  • @bar = @foo[2..4]; # @bar gets the list (14,16,undef)
  • @foo[1..2] = (1066,1492); # @foo is the list (14,1066,1492,16)
• use splice to insert an element or an array into an existing array–
  • splice(@foo,2,0,(1,2,3)); # @foo becomes (14,1066,1,2,3,1492,16)
  • splice(@foo,2,3,(1,2)); # @foo becomes (14,1066,1,2)
• to empty an array set it equal to the empty list ()– @array = (); or $#array = -1;.
• push adds an array entry at the end of the array and returns length of array– push(@array,"new thing");.
• pop 'pops' off the last item of array and returns its value.
• shift 'shifts' off the first item of array, returns it and moves the rest 'up' so to speak!
• unshift prepends array/list₂ to array₁ and returns the array₁ length– unshift @array, @other_array, or unshift @array, list.
• to iterate use either foreach $element (@array) {…} or for (0..$#array) {…}.
• cheap reference to last element of array is $array[-1].
• sorting: @Newarray = sort @array;.
• returning a array from a function: No problem, i.e. return @array;.
• Cute version: @rray.
• To reverse an array: @array = reverse @array;.

Hashes

• notation is my %hash.
• creating: %hash = (key1 => value1, key2 => value2, key3 => value3);.
• reference is $hash{$key} NOTE– leading $ as above.
• assignment is $hash{key} = $value;. If key exists prior, re-assign $value, else create new entry with $key as key (duh!) and $value as new value.
• size of a hash is print "hash size = ",scalar(keys(%hash)),"\n";
• check for existance: if(exists($hash{$key})) {…}.
• to remove a hash element: delete($hash{$key});.
• to remove ALL hash elements: %hash = ();.
• iteration over a hash: while (($key,$value) = each(%hash)) {…}.
• key iteration over a hash: foreach $key (keys %hash) {…}.
• value iteration over a hash: foreach $value (values %hash)) {…}.
• sorting: By key, foreach $key (sort keys %hash) {…}.
• sorting: By value, foreach $value (sort values %hash) {…}.
• merging two hashes: %newhash = (%hash1,%hash2);.
• hash as set: $hash{$key_to_test_for_membership} or die "No such member of set\n";.
• returning a hash from a function: No problem, i.e. return %hash;.

Refs

• @array as a reference is @{$ref}.
• reverse @array as a reference is reverse @{$ref}.
• @array[42] as a reference is @{$ref}[42].
• @array[7] = 11 as a reference is @{$ref}[7] = 11.
• %hash as a reference is %{$ref}
• keys %hash as a reference is keys %{$ref}
• $hash{'the answer'} as a reference is %{$ref}->{'the answer'}
• $hash{'the answer'} = 42 as a reference is %{$ref}->{'the answer'} = 42
• To make a reference to a module sub/method, say new from module 'bar', this would look like:

  $x = sub{bar->new(@_)};
  $x->("thing1","thing2");

  alternatively:

  bless \$x, "bar";
  (\$x)->new("thing1","thing2");

• A hash reference like: %{$ref}->{key} can be simplified to $ref->{key}.
• To quote the 'masters':²
  
  
  • $ $arrayref [2] = "Dorian";
  • ${ $arrayref }[2] = "Dorian";
  • $arrayref->[2] = "Dorain";
    
    
  • $ $hashref {KEY} = "F#major";
  • ${ $hashref }{KEY} = "F#major";
  • $hashref->{KEY} = "F#major";
    
    
  • & $coderef (Presto => 192);
  • &{ $coderef }(Presto => 192);
  • $coderef->(Presto => 192);


• As a way of clarifying code, given my_sub(\@array) then:
  
  
  sub my_sub {
          my $ref = shift;
          my @array = @$ref;
          for(@array) {
                  ↓
  
  
  works nicely.

Modules

• use strict;
• use warning;
• use diagnostics;

• use File::Find;
• use Cwd;

  As an example:
  
  

  
  
  sub fullnameURL {
   return "file://" . realpath(cwd() . "/" . shift);
  }
    
  

  
  
• use Data::Dumper; or use Data::Dumper::Simple; At this point, I don't even bother to use the original Dumper, I just use Simple…

  Learn syntax for calls to
  print Data::Dumper->Dump( [ \@checkboxlist ], [qw(*checkboxlist)] ), "\n"
  print Data::Dumper->Dump( [ \%checkboxlists ], [qw(*checkboxlists)] ), "\n"
  
  Contrast that with the syntax of Data::Dumper::Simple, i.e.
  print Dumper(@checkboxlist,%checkboxlists),"\n";
  

• use Getopt::Std;
• use Pod::Usage;
• use Text::CSV;
• use Text::Wrap;
• use feature ":5.10";
• use Carp;
• use autodie;
• use File::Basename;

Vernacular/Idiom

• CPAN---use modules instead of rolling your own code. Take advantage of someone else's work and a lot of other people's testing!
• There are ways to use $_ advantageously; for(shift){s/\"/\'/g;s/\n//g;} in a sub for instance.
• use– use Data::Dumper(see above), when debugging complex data structures (or even simple ones if you need it!)
• Create new .pm with– h2xs -A -X -n Name (or Dir::Name).
• 'C' style v = v ? v : w– 'Perl' $v = $v or $w;
• 'C' style for(;;){…} is frowned on– use other looping contructs.
• On the other hand, Hall & Schwartz¹ suggest you use for instead of foreach!
• To 'next' your way out of an if statement:

  
      sub is_item {
          my $retval = 0;
          if (/^[A-Z]+[ .,]/ and $previous =~ /^$/) {{
  
              next if /^ABOUT PROJECT GUTENBERG-TM ETEXTS/;
              next if /^A /;
              next unless /^A/;
              next if /AUTHORITIES\.\s*-/;
              next if (/^A. / and $a_found == 1);
              $a_found = 1 if /^A./;
              $retval = 1;
          }}
          $previous = $_;
          return $retval;
      }
    
  

  The trick here is the double braces, that 'block' the normal if statement block;
• To return undef safely, remember that return; is a synonym for:

  
  
   return wantarray ? () : undef;
    
  

• To modify a parameter in place try:

  
   sub set_mode ($\@);# This is the declaration...
   sub set_mode ($\@) {
    our(@array,$val);
    local($val,*array) = @_;
    splice(
     @array, 1, 0,
     hidden(
      -name     => 'mode',
      -value    => $val,
      -override => 1,
     )
    );
   }
    
  
  

• Know about (i.e. study until you don't have to think about how or why you use this stuff!):
  • print "../logs/upload/${tablename}_log.txt\n";

    In order to differentiate text and variable names in an interpolated string.

  • shift
  • $_
  • @_
  • <>

    At least one thing to remember is that <$fh> is not the same as < $fh>_{notice the space after <}, one is a file handle and the other is a 'glob'! To use <> to slurp a file, first set $/ to either 0777_octal, or 'undef' it. An example of 'safe' slurping:

    
     # FILE is already open ...
     {
      local $/ = undef;
      $slurp = <FILE>;
     }
     # Or for __DATA__ try ...
     my $data = do { local $/; <DATA> };
       
    

  • foreach/for

    To apply a change to each element of an array:

    
     $_ *= 2 for @rray;
       
    

  • map

    To create a copy of an array with changes:

    
     @copy = map { $_ * 2 } @rray;
       
    

    To process an array with index number and current value of indexed element:

    
     my @ARRAY = (...);
     my @result = map {
      do something with $_ and $ARRAY[$_] 
     } 0..$#ARRAY;
       
    

    Then, $_ is giving you the index of the element, and you indirect it to get to the element itself.


  • grep
  • quoting
  • <<RAW; (here doc strings)

    Interpolation is on by default, or made explicit by the use of double quotes around RAW. Single quotes turn interpolation off. Don't forget the semi-colon after RAW!

  • use constant PI => 3.141111115926; To negate a numeric constant, leave a space after the minus sign!

Fragments

A correction from Aristotle concerning reading line pairs from either STDIN or __DATA__

#!/usr/bin/perl -w
use strict;

my %bookmark;
my %url;

while (<>) {
    my $name = <>;
    $url{$name} = $_;
}

for (sort keys %bookmark) {
    print $bookmark{$_};
    print $_;
}

sub get_firstline {
    my @lyrics = @{ +shift };
    my $firstline;
    for (@lyrics) {
        next if (/chorus/i);
        next unless (/^\w/);
        $firstline = $_;
        last;
    }
    return $firstline;
}

    my @lyrics = { shift() };

my @list;
my $filename_in  = $ARGV[0];
if ( $filename_in !~ /\.glo$/i ) {
    $filename_in .= '.glo';
}

open( FILE_IN, $filename_in )
    or die "Couldn't open input file '$filename_in': $!\n";
    @list = map {chomp;$_} <FILE_IN>;

for (map { glob } @ARGV) {
    # $_ is the next file to process...
}

BEGIN {
    @ARGV = map { glob } @ARGV;
}
...
foreach (@ARGV) {
 # $_ is the next file to process...
}

sub wrapper {
    my $saver = new SelectSaver(shift);

    $main::{ $_[0] }( $_[1] );
}

sub myFunction {
    my $filename = shift;

    print "\$filename = '$filename'\n";
 do domething here...
}

Here is a way of managing default parameters (options etc.) in a function call...

#!/perl/bin/perl
#
# frag.pl -- 'default' parameter options manager demo...
use strict;
use warnings;
use diagnostics;
use Carp;

myfunction(optionA=>'12',optionD=>'test');

sub myfunction {
    my %defs = ( optionA=>2e6, optionB=>'defA', optionC=>'defB' );
    my %user = ( %defs, @_ );
    my %opts;
    @opts{keys %defs} = delete @user{keys %defs};
    carp "Unknown options: '@{[ %user ]}' ignored." 
          if %user;
# %opts user known user supplied options
# defaults for unsupplied options
# Warning issued about unknown options
# do stuff.
    for (keys %opts) {
        print "$_='$opts{$_}'\n";
    }
}

Filter Template

#!/perl/bin/perl
#
# filter.pl -- One liner goes here.
use strict;
use warnings;

use diagnostics;
use Getopt::Long;
use Pod::Usage;

our $VERSION = '0.01';

GetOptions(
    'debug=i' => \( my $debug = 0 ),

    'help|?'  => \( my $opt_help ),
    'man'     => \( my $opt_man ),

    'version' => \( my $opt_version ),
) or pod2usage(2);

if ($opt_version) {
    print "filter.pl vrs. $VERSION\n";
    exit;

}
pod2usage(1) if $opt_help;
pod2usage( -verbose => 2 ) if $opt_man;

pod2usage("$0: No files given.") if ( @ARGV == 0 );

for (map { glob } @ARGV) {

    filter($_);
}

sub filter {
    my $file = shift;

    print "\$ARGV[$n]='$file'\n";
    $n++;
}

__END__

=head1 NAME

 filter - Given input, use filter to change it to output.

=head1 SYNOPSIS

filter [options] filespec

 Options:

  -debug     set debug level, default is off
  -help      brief help message
  -man       full documentation
  -version   version number

 Switches that don't define a value can be done in long or short form.

 eg:

   filter --man
   filter -m

=head1 OPTIONS

=over 8

=item B<-debug>

Display debug information as program is executed. Control is set by level of the value
passed on the command line. Default value is off (debug == 0).

=item B<-help>

Print a brief help message and exit.

=item B<-man>

Print the manual page (full documentation) and exit.

=item B<-version>

Print the version number and exit.

=back

=head1 DESCRIPTION

This is a template for generic file filter. The description goes here.

=head1 AUTHOR

Hugh S. Myers
hsmyers@sdragons.org

=head1 BUGS

None that I know of.

=head1 TODO

Not yet, just started!

=head1 UPDATES

Not yet, just started!

=cut

 

Useful Tables

File IO

Regex

Bibliography

These are not in order and they are not optional. Just buy them. Do it now...

If as some insist, you need to know what order to purchase these in, then the must haves are in the following order:

1. Programming Perl
2. Effective Perl Programming
3. Higher Order Perl
4. Perl Best Practices
5. Mastering Regular Expressions
6. Perl 5 Pocket Reference
7. Regular Expression Pocket Reference
8. Perl Cookbook
9. Object Oriented Perl
10. Writing Perl Modules for CPAN
11. Perl Objects, References and Modules

Note: These are all subject to more recent editions!

When it comes to books, there is never and end to lists! In particular there are four that make a solid 'course' on Perl and they are listed in the natural order for purchase.

'Vernacular' Version 1.27 Fri Sep 21 12:36:42 2012