Being the extensible and flexible language that it is, Perl provides us with some safeguards and helpers to assist in avoiding what happened to me (I wish I knew that back then). The first of which I’ll talk about is Pragmas.

Pragmas

Pragmas are special modules that come installed by default in every Perl distribution. They tell the interpreter of how it is supposed to act. To turn them on, all you have to do is call the special word use with the appropriate Pragma. To turn them off, call no and the Pragma in question. The most common and powerful Pragma is, in my opinion, strict (hence the name of this blog: use strict;#)).

Strict tells the Perl interpreter that all variables must be declared and tightens up security a notch. To use strict; you have to have at least working knowledge of lexical variables. It takes a while to getting used to at first, but once you’re hooked, you won’t know how you could possibly have written Perl programs without it before (I know I don’t).

#!/usr/bin/perl

$var = 1; # OK
use strict;
$var1 = 2; # compile time error

example.pl

In our example above, Perl will refuse to run, raising a compile time error like such:

Global symbol “$var1″ requires explicit package name at example.pl line 5.
Execution of example.pl aborted due to compilation errors.

That’s strict in effect. Notice that $var was not cited, since strict was only enforced below it. In order to bypass that error, we should have declared our variable with either my, our, or local – depending on the need. my is the most common. Look up “Packages, Namespaces, and Lexical scopes” for more on those 3 operators.

#!/usr/bin/perl

$var = 1; # OK
use strict;
my $var1 = 2; # OK

use strict; is so important that it is usually the second line of code in any decent Perl program – the first line being the shebang.

If you need to turn off strict for one reason or another, you can do so with the key word no.

#!/usr/bin/perl

use strict;
my $var = 1; # OK
no strict;
$var1 = 2; # also OK

When writing your Perl programs, it’s also good to turn on warnings and diagnostics. warnings will complain about possible problems such as useless uses of certain functions. diagnostics, on the other hand, will throw you a truckload of information regarding errors. It’s a good place to start when you’re stumped.

[ad#middle_end]

Perl Modules

Perl modules are pieces of code or packages that can be imported into your script with the keyword use in the same way as Pragmas. They can be Object Oriented, Procedural, or both. I will not discuss how to write a module in this post, but I will tell you where to find them for download and how to install them.

My all time favorite module is Data::Dumper. So I will use it in the following examples. The funny :: between Data and Dumper is kind of like a directory separator. The module Dumper resides in the directory Data, found in one of the paths configured in the Perl config files or the PERL5LIB environmental variable (which set the @INC array).

Data::Dumper comes installed by default, along with hundreds other modules that the developers deemed worthy. To test that your Perl distro has it, run the following command in a command line:

$ perl -MData::Dumper -e 'print "OKn"'

You’ll most definitely see the OK being printed on your screen. The command passes 2 parameters to the Perl interpreter: -M which tells it to load a module (in this case Data::Dumper – no spaces between -M and the module name, or you’ll get a “missing argument” error), and -e which tells it to execute a piece of code (we told it to print OK, but any valid piece of code would do).

Look at what would have happened if we tried to load a module that wasn’t installed:

$ perl -Maaaa -e 'print "OKn"'
Can’t locate aaaa.pm in @INC (@INC contains: /usr/lib/perl5/5.10/i686-cygwin /usr/lib/perl5/5.10 /usr/lib perl5/site_perl/5.10/i686-cygwin /usr/lib/perl5/site_perl/5.10 /usr/lib/perl5/vendor_perl/5.10/i686-cygwin /usr/lib/perl5/vendor_perl/5.10 /usr/lib/perl5/vendor_perl/5.10 /usr/lib/perl5/site_perl/5.8 /usr/lib/perl5/vendor_perl/5.8 .).
BEGIN failed–compilation aborted.

To install a module, you can do it the hard way or the easy way. Some modules are harder than others, so I’ll stick with the easier ones for now. Let’s start with the hard way.

First, you should know where to find your module. CPAN – The Comprehensive Perl Archive Network is the place to go to get your modules. It has a handy search engine which will search through almost 16000 modules at the time of this writing (5/2009). There you will find code ranging from the most trivial to the craziest needs. If there’s one thing that CPANs contributors don’t lack, it’s creativity (that’s a compliment).

Enter a keyword in the search engine and it will list all relative modules. Click on the link to the one that interests you most. You will be shown its documentation in POD (Plain Old Documentation) format. That’s the data you will most likely need to learn how to use your module. It should also be the most up-to-date information, since it’s kept by its authors.

At the top of the POD screen, you’ll see a breadcrumb set of links showing the Author’s name, the module’s distribution name and version, and the module name itself:

Ilya Martynov > Data-Dumper-2.121 > Data::Dumper

Click on the link for the module’s distribution name and version, to go to the distribution details screen. You will see lots of information about the module and its sub-modules, but what should concern you right now is the download link next to the release name. Click on it and download the module tarball.

Now this is where I halt and tell you that potential headaches lie ahead. There are basically 2 kinds of modules: PurePerl ones and C-based ones. PurePerl modules are just that – modules that are solely written in Perl. The vast majority of modules, however, are written in C with bindings special for Perl. Those usually have to be compiled and as such, need a C/C++ compiler and a make program. The good news is that most *nix systems come with those tools already installed or readily available. Windows systems, however, require that you install nmake and preferably Microsoft Visual C++. Check out my post about installing MQSeries module on Windows for more information on how to get Microsoft Visual C++

Back to installing the module…

Unpack your module in some directory where you have full access. I like to keep an untouched copy of the tarball, by reading the gunzipped contents and throwing it to the screen with the -c option, and piping it to tar with xvf - parameters:

gunzip -c tarball.tar.gz | tar -xvf -

You’ll end up with a directory having the name of your distribution. Go in there and read all README files you can find. Read the INSTALL files if any.

One of the files you’ll see in the directory is Makefile.PL. That’s the kickoff file for the installation. It takes the following optional parameters: PREFIX, LIB, and INC, and creates a makefile tailor made for your system. It’s important to set the PREFIX parameter if you want the module installed in a place other than the default. LIB and INC point to the C lib and include directories, respectively.

Now that you have your makefile, it’s just a matter of running make, make test, and finally make install. Depending on the module, you should have no issues whatsoever. Other more “sensitive” modules, however, often require hours of work and even some tweaking of the makefiles by hand. DBD::Oracle is by far the craziest module I’ve ever had to install. In some machines it’s a piece of cake, and others it manages to amuse with the amount of errors it pulls out of the hat. Anyway…

That was the hard way. Now for the easy way.

[ad#middle_end]

CPAN

If you’re finding it strange to see the CPAN title here when I’ve already talked about it above, don’t worry – I’m talking about the application CPAN and not the website.

Perl comes with the CPAN module installed, and most of the time it also creates a script in the bin directory called cpan. It’s an interactive shell that allows you to fetch information regarding authors and modules, and also allows you to install modules without having to go through the whole process of downloading the distribution, unpacking, etc.

Start up the CPAN application by calling

$ perl -MCPAN -e shell

If it’s the very first time you call it, you will be promped to answer a series of questions. Sticking to the default values is almost always OK. One of the first questions you will be asked is if you want CPAN to configure everything automatically. I recommend against it unless you know that the defaults are correct and will enable you to successfully install modules. And if you know that, then you probably already know how to use the CPAN application and this post has nothing new.

Once the questions have been answered, you will be presented with a cpan prompt. Type ? to know what options you have.

cpan[1]> ?
Display Information                                                (ver 1.9205)
 command  argument          description
 a,b,d,m  WORD or /REGEXP/  about authors, bundles, distributions, modules
 i        WORD or /REGEXP/  about any of the above
 ls       AUTHOR or GLOB    about files in the author's directory
    (with WORD being a module, bundle or author name or a distribution
    name of the form AUTHOR/DISTRIBUTION)

Download, Test, Make, Install...
 get      download                     clean    make clean
 make     make (implies get)           look     open subshell in dist directory
 test     make test (implies make)     readme   display these README files
 install  make install (implies test)  perldoc  display POD documentation

Upgrade
 r        WORDs or /REGEXP/ or NONE    report updates for some/matching/all modu
les
 upgrade  WORDs or /REGEXP/ or NONE    upgrade some/matching/all modules

Pragmas
 force  CMD    try hard to do command  fforce CMD    try harder
 notest CMD    skip testing

Other
 h,?           display this menu       ! perl-code   eval a perl command
 o conf [opt]  set and query options   q             quit the cpan shell
 reload cpan   load CPAN.pm again      reload index  load newer indices
 autobundle    Snapshot                recent        latest CPAN uploads

Use o conf to display the parameters to which you answered all those questions. You can change them with o conf as well. If you didn’t enable auto-commit before, you will have to call o conf commit to save your changes for use in future sessions.

o conf http_proxy "http://some_proxy.com:80"

The m command allows you to fetch information regarding a certain module.

cpan[2]> m Data::Dumper
.... Possibly some data about fetching updated files from the internet here ....
Module id = Data::Dumper
    DESCRIPTION  Convert data structure into perl code
    CPAN_USERID  GSAR (Gurusamy Sarathy )
    CPAN_VERSION 2.121
    CPAN_FILE    I/IL/ILYAM/Data-Dumper-2.121.tar.gz
    DSLIP_STATUS SdpOp (standard,developer,perl,object-oriented,Standard-Perl)
    MANPAGE      Data::Dumper - stringified perl data structures, suitable for b
oth printing and C
    INST_FILE    /usr/lib/perl5/5.10/i686-cygwin/Data/Dumper.pm
    INST_VERSION 2.121_14

In the output above, CPAN tells us that we alreay have Data::Dumper version 2.121_14 installed. If you are not sure what is the exact name of a module, use the i command to fetch information using a regex:

cpan[3]> i /klingon/
Distribution    JALDHAR/DateTime-Event-Klingon-1.0.1.tar.gz
Distribution    PNE/Lingua-Klingon-Collate-1.03.tar.gz
Distribution    PNE/Lingua-Klingon-Recode-1.02.tar.gz
Distribution    PNE/Lingua-Klingon-Segment-1.03.tar.gz
Module    DateTime::Event::Klingon (JALDHAR/DateTime-Event-Klingon-1.0.1.tar.gz)

Module    Lingua::Klingon::Collate (PNE/Lingua-Klingon-Collate-1.03.tar.gz)
Module    Lingua::Klingon::Recode (PNE/Lingua-Klingon-Recode-1.02.tar.gz)
Module    Lingua::Klingon::Segment (PNE/Lingua-Klingon-Segment-1.03.tar.gz)
8 items found

Once you’re happy with the module name, you can check if it’s installed or not using m

cpan[4]> m Lingua::Klingon::Collate
Module id = Lingua::Klingon::Collate
    CPAN_USERID  PNE (Philip Newton
)
    CPAN_VERSION 1.03
    CPAN_FILE    P/PN/PNE/Lingua-Klingon-Collate-1.03.tar.gz
    INST_FILE    (not installed)

Install it with install command.

cpan[5] install Lingua::Klingon::Collate

Now, unless you already have module Test::Differences installed, Lingua::Klingon::Collate will fail with a dependency error. Not all modules are like that. Some are coded in a way that CPAN actually asks you if you want to follow and install dependencies automagically. Those are a cinch to install.

If something goes wrong, look at the output of the installation. Best case scenario, you’re just missing another module and it didn’t warn you about it. For example, after Lingua::Klingon::Collate failed with the warning that I should have Test::Differences installed, I tried to install that dependency directly. It also failed. When looking at the output on the screen, I see a bunch of lines like this:

t/regression..........Can't locate Text/Diff.pm in @INC (@INC contains: /home/vi
alves/.cpan/build/Test-Differences-0.4801-lI_xia/blib/lib /home/vialves/.cpan/bu
ild/Test-Differences-0.4801-lI_xia/blib/arch /usr/lib/perl5/5.10/i686-cygwin /us
r/lib/perl5/5.10 /usr/lib/perl5/site_perl/5.10/i686-cygwin /usr/lib/perl5/site_p
erl/5.10 /usr/lib/perl5/vendor_perl/5.10/i686-cygwin /usr/lib/perl5/vendor_perl/
5.10 /usr/lib/perl5/vendor_perl/5.10 /usr/lib/perl5/site_perl/5.8 /usr/lib/perl5
/vendor_perl/5.8 .) at /home/vialves/.cpan/build/Test-Differences-0.4801-lI_xia/
blib/lib/Test/Differences.pm line 213.

You’ll notice that the error is the same as when we did the $ perl -Maaaa -e 'print "OK"'. Module Text/Diff.pm (or namely Text::Diff) is not installed. So we now go on that quest of following dependencies by hand.

It so happens that Test::Differences tried to install Text::Diff, but Text::Diff failed during the test phase. Suppose I know that those failed tests are not important and won’t hinder the results of the rest (I don’t, but bare with me), I can force CPAN to disregard the test failures:

cpan[6]> force install Text::Diff
Running install for module 'Text::Diff'
Running make for R/RB/RBS/Text-Diff-0.35.tar.gz
  Has already been unwrapped into directory /home/vialves/.cpan/build/Text-Diff-
0.35-B8Qsuo
  Has already been made
Running make test
/usr/bin/perl.exe "-MExtUtils::Command::MM" "-e" "test_harness(0, 'blib/lib', 'b
lib/arch')" t/*.t
t/ext_format......ok
t/general.........Use of /g modifier is meaningless in split at t/general.t line
 129.
Use of /g modifier is meaningless in split at t/general.t line 130.
t/general.........ok
t/inputs..........ok
t/keygen..........ok
t/outputs.........1/8 No such file or directory at t/outputs.t line 12, 
line 6.
t/outputs......... Dubious, test returned 2 (wstat 512, 0x200)
 Failed 4/8 subtests
t/table...........ok

Test Summary Report
-------------------
t/outputs.t   (Wstat: 512 Tests: 4 Failed: 0)
  Non-zero exit status: 2
  Parse errors: Bad plan.  You planned 8 tests but ran 4.
Files=6, Tests=29,  1 wallclock secs ( 0.04 usr  0.04 sys +  0.59 cusr  0.26 csy
s =  0.93 CPU)
Result: FAIL
Failed 1/6 test programs. 0/29 subtests failed.
make: *** [test_dynamic] Error 255
  RBS/Text-Diff-0.35.tar.gz
  /usr/bin/make test -- NOT OK
//hint// to see the cpan-testers results for installing this module, try:
  reports RBS/Text-Diff-0.35.tar.gz
Running make install
Installing /usr/lib/perl5/site_perl/5.10/Text/Diff.pm
Installing /usr/lib/perl5/site_perl/5.10/Text/Diff/Table.pm
Writing /usr/lib/perl5/site_perl/5.10/i686-cygwin/auto/Text/Diff/.packlist
Appending installation info to /usr/lib/perl5/5.10/i686-cygwin/perllocal.pod
  RBS/Text-Diff-0.35.tar.gz
  /usr/bin/make install  -- OK
Failed during this command:
 RBS/Text-Diff-0.35.tar.gz                    : make_test FAILED but failure ign
ored because 'force' in effect

Now I can go on to installing Text::Differences and finally Lingua::Klingon::Collate.

cpan[7] install Test::Differences
.... some output here ....
Appending installation info to /usr/lib/perl5/5.10/i686-cygwin/perllocal.pod
  OVID/Test-Differences-0.4801.tar.gz
  /usr/bin/make install  -- OK

cpan[8] install Lingua::Klingon::Collate
Running install for module 'Lingua::Klingon::Collate'
Running Build for P/PN/PNE/Lingua-Klingon-Collate-1.03.tar.gz
  Has already been unwrapped into directory /home/vialves/.cpan/build/Lingua-Kli
ngon-Collate-1.03-MX7FZn
  -- No Build created, won't make
Running Build test
  Make had some problems, won't test
Running Build install
  Make had some problems, won't install

Ok, that happens. It’s because of the previous bad attempt. We can bypass that by telling CPAN to restart the build from scratch. To do so, it must first clean the build environment for that module.


cpan[9] clean Lingua::Klingon::Collate


That usually does the trick and enables you to run the install again, but if it doesn’t, you can force get Lingua::Klingon::Collate to get a fresh package.

cpan[27]> install Lingua::Klingon::Collate
Running install for module 'Lingua::Klingon::Collate'
Running Build for P/PN/PNE/Lingua-Klingon-Collate-1.03.tar.gz
  Has already been unwrapped into directory /home/vialves/.cpan/build/Lingua-Kli
ngon-Collate-1.03-ZA4a1s

  CPAN.pm: Going to build P/PN/PNE/Lingua-Klingon-Collate-1.03.tar.gz

Checking whether your kit is complete...
Looks good

Checking prerequisites...
Looks good

Creating new 'Build' script for 'Lingua-Klingon-Collate' version '1.03'
Copying lib/Lingua/Klingon/Collate.pm -> blib/lib/Lingua/Klingon/Collate.pm
Manifying blib/lib/Lingua/Klingon/Collate.pm -> blib/libdoc/Lingua.Klingon.Colla
te.3pm
HTMLifying blib/lib/Lingua/Klingon/Collate.pm -> blib/libhtml/site/lib/Lingua/Kl
ingon/Collate.html
./Build: blib/lib/Lingua/Klingon/Collate.pm: cannot resolve L in par
agraph 60.
./Build: blib/lib/Lingua/Klingon/Collate.pm: cannot resolve L in par
agraph 60.
  PNE/Lingua-Klingon-Collate-1.03.tar.gz
  ./Build -- OK
Running Build test
t/01_base...........ok
t/02_strcoll........ok
t/03_strxfrm........ok
t/04_strunxfrm......ok
t/05_list...........ok
All tests successful.
Files=5, Tests=87,  1 wallclock secs ( 0.05 usr  0.03 sys +  0.52 cusr  0.25 csy
s =  0.85 CPU)
Result: PASS
  PNE/Lingua-Klingon-Collate-1.03.tar.gz
  ./Build test -- OK
Running Build install
Prepending /home/vialves/.cpan/build/Lingua-Klingon-Collate-1.03-ZA4a1s/blib/arc
h /home/vialves/.cpan/build/Lingua-Klingon-Collate-1.03-ZA4a1s/blib/lib to PERL5
LIB for 'install'
Installing /usr/lib/perl5/site_perl/5.10/Lingua/Klingon/Collate.pm
Installing /usr/share/man/man3/Lingua.Klingon.Collate.3pm
Installing /usr/share/doc/perl-5.10.0/html/html3/site/lib/Lingua/Klingon/Collate
.html
Writing /usr/lib/perl5/site_perl/5.10/i686-cygwin/auto/Lingua/Klingon/Collate/.p
acklist
  PNE/Lingua-Klingon-Collate-1.03.tar.gz
  ./Build install  -- OK

Type q to exit the shell and that’s it! There are many other options when using CPAN, but what you’ve seen so far in this post should be enough to get you started. Just remember to use ? every now and then to see what powers are offered to you.

Control Structures are used to control the flow of a program. We are going to see programs that can iterate (loop) or make decisions (conditionals) based on the state of variables.

More interesting possibilities arise when we introduce control structures and looping. Perl supports lots of different kinds of control structures which tend to be like those in C, but are very similar to Pascal, too.




Conditionals

The simplest control structures are the if and unless statements. Its syntax basically follows the rule below:

if ( expression ) {
    instruction1;
    instruction2;
}

Value obtained from “expression”, determines whether it will be considered as true or false. Table below helps you to identify the meaning of values based on how Perl interprets expressions.

Everything in Perl is true, except:

• the strings “” (the empty string) and “0″ (the string containing only the character, 0), or any string expression that evaluates to either “” (the empty string) or “0″.
• any numeric expression that evaluates to a numeric 0.
• any value that is not defined (i.e., equivalent to undef).

A very simple example of a real “if statement” would be:

if ( $name ) {
    print "Non empty string";
}
else {
    print "Empty string";
}

Another example, to illustrate the syntax of the “if” statement:

if ( $money <= 0 ) {
    print "You are out of money";
}
elsif ( $money > 1000000 ) {
    print "You are a millionaire";
}
else {
    print "You are probably better than I am";
}

Blocks of code in Perl are enclosed by curly braces {   }. They are always required inside a control structure (except for cases where we use idiomatic ifs – see more below).

Two things to mention:

1 – elsif spelling;
2 – both elsif and else statements are optional.

Another conditional statement we need to mention is the unless. Its meaning is the opposite of an if statement. It will only execute a block of code if expression is NOT true.

Let’s look at an example:

if  ( $num == 10 ) { #Usual if statement
    print "Number is equal to 10";
} else {
    print "Number not equal to 10";
}

# Unless statement that will execute the block of code below
# if number's value is not 10 (same thing as the else statement above)

unless ( $num == 10 ) {
    print "Number not equal to 10";
}
else {
    print "Number is equal to 10";
}

Action based on statement test

You can test a single statement and perform a pre-defined action in case it is true or another one if statement is false.

For example:

    print "You are a man" if ($gender eq "M"); # parentheses are optional here, since only one expression is evaluated



[ad#middle_end]



Ternary or Trinary Operator

Like many other programming languages, Perl offers the ternary (aka trinary) operator “?:” which behaves just like if/elsif/else:

print "You are a " . (($gender eq "M") ? "man" : "woman") . "n";
# read: if $gender eq "M" then "man" else "woman"

# or perhaps
($birthday == $today) ? print "Happy birthday!" : print "Have a good day";

Mimmic elsif this way:

$month = (localtime)[4]; # fifth element of localtime in list context returns month, base 0;

print "The month is now " .
($month == 0) ? "January" :
($month == 1) ? "February" :
($month == 3) ? "March" :
                      "something other than Jan, Feb, or March";

Operators

Initially we will introduce the testing operators. They rely on a test being considered as true or false. Following you can see a few examples:

$a == $b                      # Is $a numerically equal to $b?
# Beware: Don't use the = operator.
$a != $b                       # Is $a numerically unequal to $b?
$a eq $b                       # Is $a string-equal to $b?
$a ne $b                       # Is $a string-unequal to $b?

Perl also supports the logical operators “OR” and “AND”. The “OR” operator is represented by the “||” characters while the “AND” is represented by “&&” characters.

Lets go through a few examples:

# If value of number is greater than 10 or lesser than 5
if ( ( $num > 10 ) || ( $num < 5 ) ) {
    ...
}

# If language is equal to "perl" and num is 10, or, if num is 0 (or has a "false" value)
if ( (( $language eq "perl" ) && ( $num == 10 )) || !( $num ) ) {
    ...
}

Loops

We have several statements to perform iterations using Perl. Perl supports: while, until, do ... while, for and foreach statements.

While

Performs the iteration while the given expression is true. Syntax:

while (expression) {
    instruction1;
    instruction2;
    ...
}

Until

It is the opposite of while. So take it as, in example:

while (!(expression)) {
    instruction1;
    instruction2;
}

#same as
until (expression) {
   instruction1;
   instruction2;
}

Do .. While

Its functionality is almost the same as for the normal “while” statement, but with this kind of control structure you guarantee that the block of code will be executed at least once.

do {
    instruction1;
    instruction2;
} while (expression);

For

It’s a C like style. Syntax:

for (initialize; expression; increment/decrement) {
    instruction1;
    instruction2;
    ...
}

• The initialize statement is basically used to initialize the variable that will be used on the test statement. It can also be used anywhere in the block. Declare it with my to keep it private to the for block;
• Expression follows the same rule for if or while. It will be tested, and if its return is true, block code will be executed;
• Increment/decrement is then executed

Real example:

for ($i = 0; $i < 10; $i++ ) {
    printf "Iteration number: %sn", $i;
}

Another good example (not using a numeric expression):

for ( @names = ('John', 'Paul', 'Roger', 'David'); @names; shift(@names) ) {
    print "$names[0]n";
}

# Or work on 2 expressions at the same time
for ($i = 0, $j = 10; $i<=10,$j>=0; $i++, $j--) {
    print "$i    $jn";
}

# Or kick off an infinite loop
for ( ; ; ) {
    instruction1;
    instruction2;
}

Foreach

It is another control structure that allows iteration, but here you can iterate over an array.

Following you can see a few examples of it:

@names = ('John', 'Paul', 'Roger', 'David');

#Passing through all names
foreach $name (@names) {
    printf "%sn", $name;
}

The scalar variable is optional to the foreach statement. So you can bypass it by doing:

@names = ('John', 'Paul', 'Roger', 'David');

#Passing through all names
foreach (@names) {
    printf "%sn", $_;
}

If you don’t specify a scalar variable to get each iteration, then the default scalar ($_) will be used. Note that for can also be used as a synonym to foreach – same exact functionality, but without the each portion of the word.

Loop flow control

We have a few special commands to help us controlling the flow under a loop statement. Here we go.

last

It is similar to the “break” statement used on C programming language (as well as in several others). Tells Perl to skip the current loop statement, or even, to skip a labeled loop statement. Take a look at the example below:

@names = ('fernando', 'smith', 'Mark', 'John');
foreach (@names) {
    last if $_ eq "John";
    print "Name is " . $_ . "n";
}

next

next has the same function as the “continue” loop statement used in C. Used to force your loop statement to go to the next iteration. In example:

@names = ('fernando', 'smith', 'Mark', 'John');
foreach (@names) {
    next if $_ eq "smith";
    print "Name is " . $_ . "n";
}

The example above will just force the “foreach” statement to read next iteration once “smith” is the value read from the “names” array.

If you need to work on multiple levels of loops, you can tell next and last which named block to work on:

LINE: while () {
	next LINE if /^#/;	# discard comments
	...
}

[ad#middle_end]

« Basic Regular Expressions | TOC | Basic I/O »

« Gettin’ jiggy wit it | TOC | Control Structures »

Subroutines are user-created functions that execute a block of code at any given place in your program. It is a best practice, however, to aggregate them all either at the beginning or the end the main program.

Subroutine declarations initiate with the key word “sub” . Conventionally, subroutine names are all lowercase characters

sub NAME (PROTOTYPE) BLOCK

print_hello; # subroutine can be executed/called before the actual block is created

sub print_hello {
      print "Hello worldn";
}

When we called print_hello we told Perl that we wanted the piece of code named print_hello to be executed. The result is a “Hello World” showing up on our screen. The only benefit we have from that snippet in its current form is that we won’t have to copy/paste the print statement all over our script if we want to repeat it. All we need to do is call print_hello;

Another, older, but still common form of calling it would be

&print_hello;

Parameters

As mentioned before, our previous example doesn’t do much by itself. The good news is that subroutines can take a list of parameters and do something based on what it receives. Let’s change our example for something a little better:

$me = "Vinny";

print_hello($me);

sub print_hello {
	$name = shift;
	print "Hello $namen";
}

# prints out "Hello Vinny"

Let’s take a closer look at that. During my subroutine call, I’m passing it a list of 1 element “Vinny”. That element is populated into the special array @_, which is then passed into the subroutine. Like $_, you don’t have to explicitly point out @_ when using certain array functions. In our example, we shifted the first element of @_ into our variable $name and printed it out.

It would have been possible to work directly against $_[0], yes, but doing so might be dangerous depending on what you’re doing. Here’s why: there are 2 ways of passing parameters into a subroutine.

The first and more common is pass-by-value. Pass-by-value is when we use the value of $_[0] into a variable of our own declared within the subroutine. Due to the lexical nature of subroutines ($name doesn’t exist outside of the subroutine in our example – we’ll see more about that later), the original variable ($me) is untouched.

The second and possibly dangerous way of doing it is by using the pass-by-reference method. In this case, we work against $_[0] directly, which is a reference to the variable passed. Any changes to $_[0] will affect the contents of $me. This is typically NOT what you want to do.

$me = "Vinny";

print_hello($me);
print "$men";

sub print_hello {
    print "Hello $_[0]n";
    $_[0] .= " Alves";
}

When passing more complex structures such as hashes and arrays, bear in mind that Perl flattens them out into a single array by default.

@myArray = qw(red green blue);

%myHash = ('apple'=>'fruit',  'dog' =>'pet');

print_hello(@myArray,%myHash);

sub print_hello {
	for $i (@_) {
		print "Got $in";
	}
}
# Prints :
# red
# green
# blue
# apple
# fruit
# dog
# pet

Again, that’s probably not what you wanted. To maintain the individuality and structure of your elements, you will need to pass a reference to each element as parameters, and then assign them to variables in your subroutine.

print_hello(@myArray,%myHash);

sub print_hello {

	$array_ref = shift;
	$hash_ref = shift;

	for $fruit (@$array_ref) {
		print "Got $fruitn";
	}

	print "A dog is a " . $hash_ref->{dog} . "n";
}

Returning Data

Subroutines are handy for returning some sort of data. By default, it returns 0 or 1 if the keyword return isn’t found – depending on the success or failure of the subroutine. Optionally, you can have it return a specific piece of data, such as a scalar, a list/array or reference to arrays, hashes, scalars, etc. The same rules we find in passing parameters apply to returning data.

#!/usr/bin/perl

$num1 = 10;
$num2 = 5;
$result = compare($num1,$num2);

print $result; # "is greater"

sub compare {
    return "is greater" if $_[0] > $_[1];
    return "is smaller" if $_[0] < $_[1];
    return "is equal"  if $_[0] == $_[1];
}

Here is another way to see the same results:

#!/usr/bin/perl

use strict;

$num1 = 10;
$num2 = 5;
$result = compare($num1,$num2);

print $result; # "is greater"

sub compare(@) {
	if ($_[0] > $_[1]) {
		"is greater"; # "return" operator not required
	}
	elsif($_[0] == $_[1]) {
		"is equal";
	}
	else {
		"is less than";
	}
}

As you can see, we didn't use the return operator in the example above. It is not required here because Perl will automatically return the value of the last statement evaluated. It's not a best practice to do it this way though. We strongly recommend that you keep your returns where they're supposed to be.

[ad#middle_end]

Prototypes

In order to bypass the flattening out of all the array and hash parameters into a single array, Perl allows us to specify prototypes for our subroutines. This tells our program if we're expecting an Array, or a Hash, or to treat the elements passed as individual references instead of flattening them out. It also lets us define which parameters are mandatory and which are optional.

There are ways of overriding (turning off) prototypes. By calling the subroutine in the "old" fashion (&my_proto; or &my_proto()) for instance, the checking will not be done. Calling subroutines as methods in Object Oriented Perl also turns it off.

The catch with prototypes is that you have to declare the subroutine BEFORE actually calling it. Look at the following example:

#!/usr/bin/perl -w

@array = qw(a b c );

my_proto(@array,'test');

sub my_proto(@) {
	print "@_n";
}
# Warns the following message:  main::my_proto() called too early to check prototype at ./test.pl line 5.
# and prints "a b c test"

In this example, the subroutine and its prototype are declared after the call. Perl warns that the call was too early to check prototype and treats the subroutine as if it didn't have any. The correct way of doing it would be this:

#!/usr/bin/perl -w

sub my_proto(@); # pre-declare the sub

@array = qw(a b c );
my_proto(@array,'test');

sub my_proto(@) {
	print "@_n";
}
# Compilation error:
# Too many arguments for main::my_proto at ./test.pl line 8, near "'test')"
# Execution of ./test.pl aborted due to compilation errors.

This time the script didn't even compile (remember that Perl is an interpreted AND compiled language). Prototype checking was in place and raised the error which aborted compilation.

You probably realized that the error message we got is the same as the ones we get when we fail to provide built-in functions the right parameters. That's exactly what prototyping does - it allows you to make your subroutines behave like built-in functions.

The perlsub section in perldoc shows the kinds of prototypes that we can use to mimick the built-in functions:

		Declared as		Called as

		sub mylink ($$)		mylink $old, $new
		sub myvec ($$$)		myvec $var, $offset, 1
		sub myindex ($$;$)	myindex &getstring, "substr"
		sub mysyswrite ($$$;$)	mysyswrite $buf, 0, length($buf) - $off, $off
		sub myreverse (@)	myreverse $a, $b, $c
		sub myjoin ($@)		myjoin ":", $a, $b, $c
		sub mypop (@)		mypop @array
		sub mysplice (@$$@)	mysplice @array, @array, 0, @pushme
		sub mykeys (%)		mykeys %{$hashref}
		sub myopen (*;$)	myopen HANDLE, $name
		sub mypipe (**)		mypipe READHANDLE, WRITEHANDLE
		sub mygrep (&@)		mygrep { /foo/ } $a, $b, $c
		sub myrand (;$)		myrand 42
		sub mytime ()		mytime

Notes:

• ';' is used to separate mandatory (to the left of ; ) from optional fields (to the right).
• @, $, %, etc. makes the sub require that exact element in the position in which it was declared.
• sub mysub([@$%]) allows you to call mysub with a $var, or @array, or %hash, etc.
• sub mysub($) when called with mysub(@array) will force the array to be handled in SCALAR context

Another catch of declaring subs with prototypes is that you will get a warning if you declare your sub with a given prototype first, and then again with the rest of the code and a different prototype. Let's look at a couple of examples to get a better idea of what I mean.

Example 1

#!/usr/bin/perl -w

sub mysub(@); # defined in array context

@array = qw(a b c);

mysub(@array);

sub mysub($) {  # defined in scalar context
	print "@_n";
}
# Prototype mismatch: sub main::mysub (@) vs ($) at ./test.pl line 15.
# prints out "a b c"

Example 2

#!/usr/bin/perl -w

sub mysub($) {  # defined in scalar context
	print "@_n";
}

@array = qw(a b c);

mysub(@array);

# works just fine
# prints out "3" due to the scalar context in which the sub is defined.

Lexical Scopes

Perl by default is a very loose language. It lets you get away with things that other languages would never dream of - like using global variables indiscriminately. It's all fine and good if you want to write a quick and dirty script that isn't more than a few lines long, but if you're trying to build a complex application such as a bulletin board system (Matt Wright's wwwboard was written in (horrible) perl), you will probably find yourself missing a few toes after all the shots you foot took.

A solution for this problem is to ALWAYS use strict. Strict is a pragmatic module (or just pragma) that enforces several security measures such as having to pre-declare your variables, and another large list of constraints. It should always be the second line of your program (being the shebang the first line).

One of the things that use strict; enforces the most is to have you make good usage of lexical scopes. Lexical scopes mean that you can't access a variable that was not pre-declared, or somehow imported into the current block of code.

#!/usr/bin/perl -w

$name = 'vinny';

myprint();

sub myprint() {
	print "$namen";
}
# main::myprint() called too early to check prototype at ./test.pl line 7.
# vinny

The example above accesses the value of the global variable $name from within the subroutine. That is not a very safe thing to do. If we turn on strict, we get an error when trying to do that. The error, however, is because we didn't declare $name with either my, local, or our.

#!/usr/bin/perl -w

use strict;

$name = 'vinny';

myprint();

sub myprint() {
	print "$namen";
}

# main::myprint() called too early to check prototype at ./test.pl line 7.
# Global symbol "$name" requires explicit package name at ./test.pl line 5.
# Global symbol "$name" requires explicit package name at ./test.pl line 11.
# Execution of ./test.pl aborted due to compilation errors.

Changing the script above to comply with strict, we are once again able to access the global $name, but we still don't want to do that, especially if we want to modify the value of $name only inside the subroutine.

#!/usr/bin/perl -w

use strict;

my $name = 'vinny'; # added my to comply with strict

myprint();

print "$namen";

sub myprint() {
	$name .= " Alves"; # changes the original variable instead of a private one
	print "$namen";
}

# main::myprint() called too early to check prototype at ./test.pl line 7.
# vinny Alves
# vinny Alves

So it's best if we play it safe and not work on global variables at all. This is especially the case if you one day plan on writing scripts to use with Apache/mod_perl.

#!/usr/bin/perl -w

use strict;

my $name = 'vinny'; # added my to comply with strict

myprint($name); # calls the sub

print "$namen"; # $name here still has the original value

sub myprint() {
	my $name = shift;
	$name .= " Alves";
	print "$namen";
}
# main::myprint() called too early to check prototype at ./test.pl line 7.
# vinny Alves
# vinny

Context and wantarray

Something that often catches Perl beginners off guard is the concept of context. Calling an @array in scalar context will return the number of elements, and not the elements themselves. We can mimick this behavior with wantarray. This is how it works:

#!/usr/bin/perl

use strict;

my @array1 = qw(a b c d e);
my @array2 = reverse_or_count(@array1);
my $count = reverse_or_count(@array1);

print "@array2n";
print "$count";

sub reverse_or_count(@){
	my @arr = @_;
	if (wantarray) {
		return reverse @arr;
	}
	else {
		return $#arr + 1; # last index of @arr plus 1
	}
}

Thanks to the wantarray operator returns true if the subroutine is being called in an array context, and false if not. With that kind of control, the sky is the limit .

Closures

Closures are usually thought of as very advanced topics, but they're not that bad at all. They're basically a way to work with lexical variables inside referenced subroutines. OK, I admit that that sounded terrible, but with a simple example we can clarify it.

#!/usr/bin/perl

use strict;

sub make_counter() {
	my $start = shift;
	return sub { $start++ }
}

my $from_ten = make_counter(10);
my $from_three = make_counter(3);

print $from_ten->();    # 10
print $from_ten->();    # 11
print $from_three->();  # 3
print $from_ten->();    # 12
print $from_three->();  # 4

This is how it works: Our sub make_counter takes the initial parameter into its own private $start variable and then returns an anonymous subroutine - the auto-incrementation of $start. So when we call make_counter(10) we are actually creating a reference to the auto-increment with the initial value of 10. The beauty of it is that the value isn't lost when it comes out of scope. It's saved in memory for the next time it's called. That's why calling $from_ten->() will increment on top the latest result.

What is even nicer is that we can create as many instances of that subroutine reference as we want. Calling $from_three->() will not impact the results of $from_ten->().

That is pretty much all there is to it. Use your creativity to do the rest.

[ad#middle_end]

« Basic I/O | TOC | File and directory tests and manipulation »

General functions

print [FILE HANDLE] list of data

Used to print data. If not passed a FILE HANDLE, it will print directly to STDOUT. Interpolation rules apply. Some interesting details about print are:

print @array;  # prints all elements of @array with
               # no spaces between them
print "@array";  # prints the elements WITH spaces between them
print $var1, $var2, @array;  # prints values with no spaces between them
print FH "some data";  # prints the string "some data" inside file represented by FH (see open below).
# Note the lack of comma between the FH and the data to be printed.

open (FILE HANDLE, mode, filename) or open (FILE HANDLE, “modefilename”)

Opens a file or pipe for reading/writing/appending. Normally filehandles tend to be constants in uppercase, but it’s good practice to use variables to hold your filehandles. That way you can pass them between functions without occupying the main namespace. There are 2 styles of open – old style with 2 parameters and new style with 3.

open‘s modes are:
< (readonly),
> (create/write/truncate),
>> (create/write/append),
+< (read/write/truncate),
+> (create/read/write/truncate),
+>> (create/read/write/append)

# old style - for reading
open (FH, "</path/to/somefile.txt") || die("Can't open file: $!n"); # $! returns the system error
# do something here
close(FH);

# new style - also for reading
open (my $fh, "<", "/path/to/somefile.txt") || die("Can't open file: $!n");
# do something here
close($fh);

When working with pipes, filenames begining with | indicate a pipe to write to. Filenames ending with | indicate filenames to read from. Use the special minus ‘-’ sign to read from standard input.

printf($format_string,$value1[,$value2,$valueN]) print‘s older brother – takes patterns and prints a formatted string. It is extremely powerful and most people do not use it to its full extent.

These are the formatting options you can use:

printf("Hello, My name is %s. Today is the %dth day of %s.", $name,$day,$month);
printf("This item costs $%.2f.",$some_number);  # escape the dollar sign
printf("I need 2 %%'s to get one printed with printf");

sprintf($format_string,$value1[,$value2,$valueN])

Works the same as printf, but instead of printing the output, it returns the formatted string (allowing you to store it in a variable for later use).

$string1 = sprintf("Hello, My name is %s. Today is the %dth day of %s.", $name,$day,$month);
$string2 = sprintf("This item costs $%.2f.",$some_number);  # escape the dollar sign
$string3 = sprintf("I need 2 %%'s to get one printed with printf");

[ad#middle_end]

warn($message)

Use warn to print messages into STRERR without exiting your script. Besides the regular usage of letting the user know when something goes bad (but not fatally so), I also find it handy to filter data from a given input file using print and warn along with shell redirectors (>log.out and 2>err.out). See the example below to better understand what I’m talking about.

# in odd_even.pl
foreach my $i (0..10) { # .. = "to", so for $i == 0 to $i == 10
	if ($i % 2 == 0) { # Modulus (%)  operator, returns the remainder of a division
		print "$in"; # output to STDOUT
	}
	else {
		warn "$in"; # output to STDERR
	}
}

# in the command line
./odd_even.pl > even.txt 2 > odd.txt

die($message)

Print a message into STDERR and exit the script. If the message inside the die statement ends in a newline, only the message will be printed. If no newline is found, it will print additional information such as line number and script name.

if ($some_fatal_error) {
	die("ACK!! Something went really badn"); # prints out "ACK!! Something went really bad"
}

if ($some_other_error){
	die("ACK!! Something went really bad"); # prints out "ACK!! Something went really bad at script.pl line someline"
}

Scalar functions

split (/pattern/, $string [,number_of_elements])
split breaks a string at a given pattern into an arbitrary number of pieces. It returns a list which is usually assigned into an array for later use. Use an unescaped ‘|’ (pipe) to split strings at each letter.

$string = "Hello World";
@array = split /|/,$string; # same as @array = ('H','e','l','l','o',' ','W','o','r','l','d');

$string2 = "Name,Age,Street,Phone_number,Skills";
($name,$age,$rest) = split (/,/,$string2,3); # $name has 'Name', $age has 'Age', and $rest has 'Street,Phone_number,Skills'

substr($string,offset[,length])
Returns a piece of a string starting from a given offset and having a given length. If the length is ommitted, it will return until the end of the string. Positive offsets count from left to right. Negative offsets count from right to left. It is also handy to get padding done on a string

$string = "Hello World";
print substr($string,0); # Hello World
print substr($string,3,4); # lo W
print substr($string,-5); # World
print substr($string,-5,2); # Wo

$padding_template = "00000";

foreach my $i (10, 100, 1000, 10000) {

	print substr($padding_template . $i , (length($padding_template) * -1)), "n";
	# the line above will evaluate to the following stirng:
	# print substr(00000$i,-5),n; where $i will be 10, then 100, then 1000, then 10000

}

# results in
# 00010
# 00100
# 01000
# 10000

chop($string)
Used to cut off and return the last character of a string. The variable is altered automatically. Note: you cannot chop on a literal string. The value to be chopped must reside in a variable. The reason for that is due to chop modifying the original string to hold the chopped version.

$string = "Hello World";
$chopped = chop($string);

print $string; # Hello Worl
print $chopped; # d

chomp($string)
Similar to chop, however it will only remove the last character if and only if it is a newline (n). The same applies to not being able to chomp a literal string. See the shorthand example if you want to assign/chomp during the same command.

$string = "Hello World";
chomp($string); # no change, since there's no n at the end of $string

chomp($string2 = "with newline n"); # shorthand version
print $string2, $string; # with newlineHello World

pack and unpack
A couple of the most powerful string manipulation functions (inherited from C), it’s so complex that I recommend that you read this to see how it works.

Array functions

join
Opposite of split. Takes an array and joins its values into a string using nothing, a given character, or a string as field separator. I find it handy to create large SQL queries with it. (See example below).

@array = qw(Red Green Blue Black); # qw() puts double quotes around each word separated by space
$string = join(',',@array); # $string is "Red,Green,Blue,Black"

shift and unshift
Use shift to remove and assign the first element of an array, and unshift to do the opposite. Shift is mostly used inside subroutines to get elements from the special @_ array (@_ contains all parameters passed onto a subroutine).

@colors = qw(Red Green Blue Black);

$color = shift @colors; # or shift(@colors);
print "@colors";  # Green Blue Black;
print $color; # Red

unshift(@colors,$color);
print "@colors"; # Red Green Blue Black

pop and push
Similarly to shift and unshift, pop and push work on the right site of an array.

@pets = qw(Cat Dog Bird Fish);
$mypet = pop @pets;
print $mypet; # Fish
print "@pets"; # Cat Dog Bird

push(@pets,$mypet);
print "@pets"; # Cat Dog Bird Fish

array slices
Not a function, but a syntax structure which allows you to access subsets of an array. Keep in mind Perl’s singular/plural constructs (using @ instead of $) while using a list, array, or range as your index.

@pets = qw(Cat Dog Bird Fish);
print $pets[0]; # Cat - NOT a slice
print @pets[0,1,2]; # CatDogBird
print @pets[0..2]; # same thing
print @pets[qw(0 1 2)]; # same thing

Hash functions

each
each iterates through the key/value pairs of a hash, returning them in a list context.

while(($key,$value) = each (%hash)) {

	print $key, " => ", $value, "n"; 

}

# Prints
# key1 => val1
# key2 => val2

exists
Checks for the existence of a key in a hash. Will return true even if the key’s value is false (undefined, empty string, zero, etc.).

%hash = (key1 => undef,
         key2 => 'val2');

print "Got it!!" if exists($hash{key1}); # returns Got it!!

delete
Removes a key/value pair from a hash. Use it when you want exists to return false.

delete($hash{key1});

print "Got it!!" if exists $hash{key1}; # does not print anything

[ad#middle_end]

« References and Complex Data Structures (CDS) | TOC | Basic Regular Expressions »

Now that we have a pretty good understanding of the 3 types of data in Perl, it’s time we bump it up a notch and put them all together. Perl is most famous for its text manipulation using regular expressions, but it should also be noted by the ability to create multilevel data structures, regardless of them being scalars, arrays, or hashes.

One way that I like to explain multilevel or multidimensional data is by taking ‘Folders’ panel the Windows Explorer windows as example:

Example of Multilevel Folders

As you can see (despite the bad image quality), there is the main drive (root variable), which contains several folders (arrays/hashes) or files (scalar elements). These folders in turn can contain other folders (arrays/hashes) and files (scalar elements). In Perl you can have any kind of variable (array, hash, or scalar) containing any number of nested arrays, hashes, or scalars. This is done thanks to references, and anonymous arrays and hashes.

Here’s how it works:

When you create a variable, its name and contents get stored in your computer’s memory. A reference is a (singular) pointer in memory to another memory address. The most common way of getting a reference to a data structure is to escape the identifier symbol ($, @, or %) with a backslash.

$array_ref = @array;
$hash_ref = %hash;

print "$array_refn";  #WRONG: you will get something similar to ARRAY(0x125f6e0)
print "$hash_refn"; #WRONG: you will get something similar to HASH(0x125f6e0)

print $array_ref->[0]; #RIGHT: prints the first element of the referenced array
print ${$array_ref}[0]; #RIGHT: same results as above
print $$array_ref[0]; #RIGHT: same thing

print $hash_ref->{key1}; #RIGHT: prints value for key 'key1'
print ${$hash_ref}{key1}; #RIGHT: same as above
print $$hash_ref{key1}; #RIGHT: same thing

In the example above, we see that we can’t just print the value of a referenced data structure by calling print and the scalar that’s holding it (scalar because it’s holding one reference – no, I can’t stress that enough). We need to dereference our reference.

The two ways of dereferencing a reference (TMTOWTDI) are either by delimiting our ref within ${} or by using the ->. You may also have noticed that we use ->[] for arrays and ->{} for hashes. Use @{$var} and %{$var} if you want to dereference the whole array or hash, instead of just one key or element. Same goes for @$var and %$var.

To create multilevel data, you can nest the references inside the assignment lists:

@arr1 = (1,2,3); # Regular single level array

@multi = (@arr1,4,5); # WRONG: results in (1,2,3,4,5)
@multi = (@arr1,4,5); # RIGHT: 3 element array, being the first element another array

$multi->[0]; # prints ARRAY(0x1233ad8)
$multi->[1]; # prints 4

$multi->[0]->[0]; # prints 1 - the first element of @arr1
$$multi[0][0]; # same thing
${$multi}[0][0]; # ditto

It is also possible and even common to assign anonymous (unnamed) data structures to scalars directly. While lists are bound by parens or the qw() function (seen in detail further along), anonymous arrays are bound by square brackets ([ ]) and anonymous hashes by braces ({ }).

$arr = []; # kick off $arr as a reference to an empty, unnamed array
$arr2 = [ 1,2,3,4 ] ; # does not have to start off empty

$arr->[0] = 'a'; # first element of $arr is now 'a'

$hsh = {}; # empty anonymous hash
$hsh->{somekey} = 'somevalue'; # added key 'somekey' with value 'somevalue'

$hsh2 =  {
                'key1' => 'val1',
                'key2' => 'val2',  # you can leave the comma
             } ; # even though you do not have any more pairs

Now that you have your references, put it all together.

@multi = ($arr, $arr2, $hsh, $hsh2, 1, 'a'); # data structure galore

print $multi->[1]->[-1]; # last element of second element: 4
                                 # Lets put it all together, no temp scalars
$VAR1 = [
                  {
                       key2' => [
                                            0,
                                            1,
                                            2,
                                            3
                                        ],
                      'key1' => 'val1'
                   },
                   'a',
                   'something',
                   [
                      'red',
                      'blue',
                      'green'
                    ]
            ];

# Results:

print $VAR1->[0]->{key1}; # val1
print $VAR1->[0]->{key2}; # ARRAY(0x1233ad8) - needs dereferencing
print $VAR1->[0]->{key2}->[2]; # third element of key2: 2
print $VAR1->[-1]->[-2]; # blue
$VAR1->[-1]->[-2] = 'yellow'; # was blue, is now yellow

If you find this all mind boggling, don’t worry – you’re not alone. Fortunately we can rely on a very handy module called Data::Dumper which is really handy for times like these. More on it later on.

« Hashes | TOC | Gettin’ jiggy wit it »

The hash is, in my honest opinion, the most important data structure in Perl. It is nothing more than what other languages call an Associative Array, but it is very powerful and one of the key features of Object Oriented Perl.

If Associative Array still doesn’t ring a bell, then think of a file cabinet. Your every day file cabinet holds files that are identified by tags. These tags are the keys to your files. The content of each file can be considered its value. So the same happens to a hash. It’s an array of key/value pairs. You can identify a hash by the symbol that starts its variable name:

%some_hash
%a
%_a_very_big_hash_name

% was chosen to identify hashes because of the similarity to a key/value pair…

Hash keys are unique, and can be made up of any character and be of any size. Depending on your key name, you might need to use it between single or double quotes.

Hash values can be anything you would normally assign to a scalar variable, including anonymous arrays and anonymous hashes (more on this when we see Complex Data Structures).

Interpolation rules apply just like with any other quoting – either for keys or values. Use “=>” (fancy comma) to separate keys from values. Regular commas work too, but are more difficult on the eyes.

%some_hash = (key1=>'val1', "some key with special chars"=>$val2 );# basic hash population
%another = (0 => 'a',   # Key 0 with value 'a'
            1 => 'b', # key 1 with value 'b'
            2 => 'c');# key 3 with value 'c'

When printing a hash, keep in mind that unlike arrays, hashes do NOT keep their keys in the order they were assigned. Perl rearranges hash element orders to maximize performance. If you need to print your keys in a certain order, you will have to sort them when accessing. We’ll see scalar, array, and hash functions in the chapter Gettin’ jiggy wit it further ahead.
The simplest way to access a hash element is to call its key. We use { } to delimit hash keys.

print %some_hash; # prints key1val1
print $some_hash{key1}; # prints val1

Note that we are accessing one element of the hash, and therefore using $ to start the variable name. The $ alone would be confused with a scalar variable $some_hash, so we have to use { } to delimit the key. You’ll get used to seeing this in your or other people’s code:

$var = 'a scalar variable';
$var[0] = 'first element of array @var';
$var{key1} = 'an element of hash %var';

Although the 3 examples above start with $var, they are totally different things. Perl won’t get confused, and neither will you if you learn to look for [ and { after a variable name.

« Arrays and Lists | TOC | References and Complex Data Structures (CDS) »

Sometimes working with one piece of data just isn’t enough. You might want to specify lists of data, and save those lists in a variable. For this purpose, Perl gives us the list and array constructs.

Lists

Lists are just that – a comma-separated list of data specified between parentheses. You can add as many pieces of data (strings, numbers, variables) to a list as your computer’s memory can hold. Here’s an example of a list:

(1, 2, 'some string here', "hello $world", $myvar);   # plain list - not very useful though

As you can see in the example above, the elements in a list in Perl don’t have to contain the same kind of data like you’ll see in some other programming languages (only int’s, char’s, strings…). However, in the example above there isn’t much you can do with that list just the way it is. You’ll probably want to access its elements and assign it to variables:

($num1,$num2,$string1,$string2,$a_var) = (1, 2, 'some string here', "hello $world", $myvar);

All the values of the list on the right have been assigned to the variables in the list on the left. Now, suppose you don’t want the second element of the list on the right. You can use undef as a placeholder in the list on the left:

($num1, undef, undef, $string2,undef) = (1, 2, 'some string here', "hello $world", $myvar); # only the first and fourth values are kept

That last undef wasn’t really necessary. That’s because if you assign one list to another, if the list on the right has more values than the list on the left, the exceeding values will be automatically trashed. The undefs in the middle, however, are required so you can get the fourth position.

[ad#middle_end]

For cases where you want only one element of a list, you can select an element of a list by placing its index between [ ] right after the closing ). Indexes in Perl start in 0 by default and are numbered from left to right. You can change the startup index value by setting the variable $[, but you don't want to do that unless you REALLY know what you're doing. To access the list elements from right to left, use negative indexes, starting at -1 for the right-most element, then -2 for the second to last, and so on.

$some_var = (1, 2, 'some string here', "hello $world", $myvar)[0];    # $some_var now holds 1
$another_var = (1, 2, ‘some string here’, “hello $world”, $myvar)[-1]; # $another_var gets a copy of $myvar
$and_yet_another = (1, 2, ‘some string here’, “hello $world”, $myvar)[(2+2-1)*6-17]; # the crazy math evaluates to 1, so you get the second element of the list

To get more than one value of a list, you can use multiple indexes separated by commas:

($num1,$string2) = (1, 2, 'some string here', "hello $world", $myvar)[0,3]; # only the first and fourth values are assigned

More about that in the chapter about Slices.

Now, suppose you need to use the same list over and over, and just don't feel like typing everything all the time. You need an Array.

Arrays

An array is the kind of variable that Perl gives you to keep your lists in. All array names start with @ (stylish A for Array) and follow the same naming rules as scalars (except for the $ part).

@some_array
@_another_array
@i

To assign a list to an array, just do it like you would a scalar. You can also use the range (..) operator:

@colors = ('red', 'blue', 'yellow'); # assign @colors a list of 3 values
@ranges = (1..10,"a".."z","XX".."XZ"); # from 1 to 10, a to z, and XX to XZ

To access individual elements, use the same [ index ] construct:

print $colors[0];  # prints out 'red' to the screen

Whoah - hold on a sec!! You saw the $ instead of @ in the example above, right? The reason we did that is because we're accessing one element of the array, and as we saw in the Scalars chapter, one of anything is a scalar. And this is where some people get confused. You see, $colors and $colors[0] are 2 totally different things (there's yet a third element to this confusion, as you'll see when we get to Hashes). The former is the scalar variable $colors, and the latter is the first element of the array @colors. To avoid mistakes while reading Perl code, be sure to check for any [ or { (not there yet) after the variable name.

Here are some array operations that you can use:

@copy_of_colors = @colors;  #  @copy_of_colors now contains 'red', 'blue', and 'yellow'
@reversed = reverse @copy_of_colors;  # yellow, 'blue', 'red'
$first_value = shift(@reversed); # $first_value gets 'yellow', and @reversed is left with 'blue', and 'red' only

The $# construct allows you to access the last index value of the array. E.g.: For our @colors array, we would get value 2 (indexes start with 0, right?) for $#colors (again, $#colors starts with a $ because it's one value). This being said, another form of accessing the last element of any value is to do this:

$last_element = $colors[$#colors]; # same as $colors[2]

We will get deeper into scalar and array functions when we reach Gettin' jiggy wit it.

Context

One very important thing you MUST know and understand is that Perl treats arrays according to context. There is scalar context and list context. They can be implicit or explicit. This is how it works:

@colors = ('red', 'yellow', 'blue');   # set up the @colors array
$count = @colors;  # count now holds number 3, because @colors has 3 elements
$count = scalar(@colors);  # same thing, but called explicitly

When we assigned @colors to $count, since $count is a scalar, Perl understood that we're talking in scalar context. When you call an array in scalar context, you'll get the number of elements inside that array.

If you need to print out an entire array, there is also a small catch:

print @colors;  # prints out 'redyellowblue'
print "@colors";  # prints out 'red yellow blue'
print '@colors';  # prints out '@colors' - no interpolation with single quotes, remember?

[ad#middle_end]

« Scalars | TOC | Hashes »

Variable Names

Scalar is the type of variable used to hold one single piece of information. Examples of scalar information are one string, one character, one object, one reference… If you can say one something, then it’s scalar.

All scalar variables start with $ and a letter or underscore. As we will see in the Regular Expressions chapter, there can be variables such as $1, $2, etc. but they are reserved by the system. $0 also exists and keeps the name of the script. The size of variable names is limited only by your imagination and common sense.

$var
$_thisName
$a_really_big_and_annoying_variable_name

Quoting, Escaping, and Interpolation

When assigning a string to a variable, you can include other variables and count on getting their values. This is called interpolation, and can be achieved by using double quotes (” “) around your string.

$name = 'Vinny';
$some_string = "My name is $namen"; # My name is Vinny

In the previous example, Perl sees that we are using double quotes, and also sees that there is a variable ($name) inside the string. So first it replaces the variable with its value and then assigns the interpolated string to the variable named $some_string.

Had we tried the previous example with single quotes, the result would have been literally My name is $name. Note that we also added a “n” in our double-quoted example, which means to go to the next line. Newline characters (n), as well as everything else is interpreted literally when using single quotes.

Interpolation can be tricky at times when we want no spaces between our variable and some part of the string, or when we want to print a variable name within a double-quoted string. The solution for this is the “” (backslash), which we saw just above. Backslashes are used for escaping and giving special meanings to certain characters.

For example:

$some_string = "My name is $namen"; # My name is $namen

Since there’s a backslash just before $, it tells Perl to NOT replace the variable $name with its value. It’s simply using the literal variable name. We could have achieved just about the same results if we had surrounded the string in single quotes, with the drawback of having a literal n at the end of our string:

If you need to use a single quote inside a single-quoted string, you can escape it with the backslash as well:

$hello = 'Welcome to usestrict's Perl Crash Course';

Follows a list of Perl’s backslashed character escapes:

Perl provides us with some handy constructs that allow us to quote strings or individual words without having to worry (much) about escaping special characters. They are:

q/some literal string/; # does not interpolate
qq/some interpolated string/; # you guessed it - interpolations galore
qx/ls -la */; # executes the command between /  /

There are more, which I will explain when we reach Arrays and Regular expressions.

It’s interesting to note that these quoting constructs don’t necessarily have to delimit the quoted subject with / /. You can choose just about any character you’d like, as long as you follow the simple rule of using the matching closing character for any of [, {, or (. For all other characters, you just need to use the same one used to open the quotes.

q[some literal string];
q{another literal string};
q|one more literal string|;
q#I can even use pound characters!#;

Concatenation

Sometimes you may want to separate a string into two different pieces, one with each kind of quoting. You can do that with concatenations. Concatenations are represented by . (dot).

$some_string = 'This is a concatenated string' . "n";

In the example above, we concatenate a single quoted-string with a newline within double quotes. Another form to concatenate strings is through the .= (concat and assign) operator. The example above could also be written like this:

$some_string = 'This is a concatenated string';
$some_string .= "n";

Numbers

Like any other programming language, Perl also holds numbers. It can hold numbers in decimal, hexadecimal, binary, or octal notation.

$a_dec_number = 1;  # your every day number 1
$a_hex_number = 0x1; # number 1 in hex notation
$a_oct_number = 01; # number 1 in octal
$a_bin_number = 0b1; # number 1 in binary

Unlike most other languages, however, you can treat numbers as strings and get away with it.

$var1 = '1'; # you can use single quotes
$var2 = "2"; # or double quotes - Perl doesn't care
print $var1 + $var2; # prints out 3

Just like we have .= to concatenate strings, there are similar operators for numbers. They are:

Example:

$i = 1; # $i is initiated with 1
$i += 5; # $i is now 6

Lastly, there are the auto-increment and auto-decrement operators: ++ and - -. They can be used either preceding or following the variable name.

$i++; # $i is now 7
$i--; # back to 6
++$i;# 7 again
--$i; # 6 once more

The difference between $i++ and ++$i is that the former returns the original value and then increments, while the latter first increments and then returns. The same goes for decrements. We can see this at work if we do a print:

print $i++ ; # prints 6
print $i; # prints 7 because of the previous increment
print ++$i; # prints 8, since it incremented before printing
print $i; # prints 8 again - no change after the previous increment

Empty or Undefined?

When you want variable to have no value, you can choose to either set it to an empty string ('' or "") or assign it the undef value.

$some_var = '';  # 2 single quotes with nothing inside
$variant = ""; # 2 double quotes with nothing inside
$other_var = undef; # using undef

We'll see undef further along the course, and understand what role it plays in boolean functions.

« Variables and Data Structures | TOC | Arrays and Lists »

Code comments: In Perl, you can add comments to the code by using the character #. Whatever is to the right of a # will not be parsed (with at least one exception: the $#array structure which we will see later in the Arrays section). You may find it annoying to not have /*  */ structure for multi-line comments, but you’ll be happy to know that you can emulate multi-line comments using POD, which we’ll see later on.

Printing: Perl prints to the screen through the command print, which takes a list of parameters as input.

Assigning: To assign values to a variable, use  = (the equals operator).

Statement separator: Every statement in Perl ends with ; (semi-colon). Failure to end a statement with ; will result in a syntax error when trying to run your script.

Math: Mathematical operators are +, -, *, /, and %, for addition, subtraction, multiplication, division, and modulus – respectively. The modulus operator returns the remainder of a division.

Now on to the scalars…

« Getting it installed on… | TOC | Scalars »