By Karl Voelker

• Dynamically-typed
• Multi-paradigm
• Multi-platform
• Flexible
• Fun!

In Perl:

• Values have types
• Variables do not

Imperative

Subroutines, control structures, mutable variables

Object-Oriented

Polymorphism, modules, multiple inheritance

List-Oriented

List assignment, list operators

Generic

Via dynamic typing

Functional

First-class functions, closures

Three kinds of variables:

Scalar

Numbers, strings, references

Array

Ordered list of scalars

Associative Array (Map, Hash)

Key/value pairs of scalars

A variable name is always prefixed by a sigil.

The sigil denotes the type of the value, not the type of the variable!

1. $foo = 1;
2. ($foo, $bar) = (1, 2);
3. ($foo, $bar, $baz) = @quux;
4. ($foo, undef, $baz) = @quux;
5. @foo = (1, "two", 3);
6. $foo[0] = 'one';
7. @foo[1,2,3] = (2, 3, 4);
8. %foo = ('foo' => 1, 'bar' => 'baz');
9. $foo{'bar'} = 342;
10. @foo{'bar', 'baz'} = (7, 8);

• 1
• 2.0
• 3.0e4

Integer operations are performed if all operands are integers.

• Double-quoted (escapes and interpolation):
  • "foo"
  • "bar\n"
  • "$foo[2]bar$baz@quux"
• Single-quoted (literal only):
  • 'foo'
  • 'bar'

. (period)

Concatenation

length

Length

substr

Substring

chomp

Remove trailing newlines

sprintf

Like C

uc, lc

Uppercase, lowercase

Regular expressions are another language altogether. Here is how Perl uses them:

($username, $domain) =
$email =~ /^(.*)\@(.*)$/;

Extract parenthesized parts of a match

$real =~ /^(\d+)\.(\d+)$/;
($int, $frac) = ($1, $2);

Extract parenthesized parts another way

$tainted =~ s/\W//g;

Global substitution

Definition:

• sub foo { ... }
• sub { ... } (anonymous)

Parameters come in @_:

sub foo {
	my ($a, $b) = @_;
	return $a + $b;
}

Call:

• foo(1, 2);
• foo 1, 2; (foo must already be declared)
• goto &foo; (replaces current call on the stack)

Lists flatten:

• (1, (2, 3), 4) becomes (1, 2, 3, 4)
• With @a = ('a', 'b', 'c'),
  (@a, 'd') becomes ('a', 'b', 'c', 'd').

Some other ways:

• 1..5 becomes (1, 2, 3, 4, 5).
• qw/some words/ becomes
  ('some', 'words').

Lists and arrays are similar and related, but not identical:

• An array is a variable.
• You can always use an array as a list.
• Some operators act in-place on array variables, so they can't work with other lists.

push

Add items to end of array

pop

Remove item from end of array

unshift

Add items to front of array

shift

Remove item from front of array

reverse

Return list in opposite order

sort

Return sorted list

grep

Return list of items meeting some criteria

map

Return list of results of subroutine call on each list item

my @a = qw/some words in 
	no particular order/;

my @sorted = sort @a;

my @sorted_by_length = sort {
	length $a <=> length $b
} @a;

my @sorted_by_last_four = sort {
	substr($a, -4) cmp substr($b, -4);
} @a;

my @s = (1..20);

my @one_digit = grep /^.$/, @s;

my @even = grep {
	$_ % 2 == 0
} @s;

my @random_75_percent = grep {
	int(rand * 100) < 75
} @s;

my @s = (1..20);

my @squares = map {
	$_ * $_
} @s;

my @products = map {
	my $first = $_;
	map {
		my $product = $first * $_;
		"$first * $_ = $product\n"
	} @s
} @s;

keys

Returns a list of the keys of a hash

values

Returns a list of the values of a hash

exists

Returns whether or not a key exists in a hash

Hashes aren't ordered, so don't count on the order of keys %h to match the order of values %h!

Perl doesn't have a boolean type. Some values are considered false, and the rest are considered true:

False values:

• undef
• Zero (integer or real)
• Empty string
• The string "0", but not "00" or "0.0"
• Empty list (or array)
• Empty hash

Perl has low- and high-precedence logical operators:

undef is an operator that:

• Undefines a variable, if given an argument
• Returns the undefined value

We usually call the undefined value undef.

Check if a value equals undef with defined.

A key can exist in a hash but have the value undef:

• Given $h{'key'} = undef,
• exists $h{'key'} is true, but
• defined $h{'key'} is false.

When you access a non-existent hash index, you get undef. This sometimes causes bugs.

Block conditionals

if (condition) { statement; statement; }
unless (condition) { statement; statement; }

One-line conditionals

statement if condition;
statement unless condition;

Expression conditionals

condition ? if-true : if-false

Block loops

for var (list) { statement; statement; }
for (init, condition, increment) { ... }
while (condition) { ... }
until (condition) { ... }
do { ... } while (condition);
do { ... } until (condition);

You may write for as foreach.

Loops may be labelled, with LABEL:.

With nested loops, outer loops must be labelled to use loop control on them.

redo LABEL;

Jump to the beginning of the current iteration of this loop.

next LABEL;

Jump to the next iteration of this loop.

last LABEL;

Leave this loop immediately.

A continue block is executed between the loop body and loop test.

If you use next to skip part of the loop body, the continue block is still executed.

while (condition) {

	# redo jumps here
	do_stuff;

} continue {

	# next jumps here
	do_other_stuff;
	# jump to loop test

}

# last jumps here

If you don't specify otherwise, any variable you use is global.

You should use strict to prevent accidental globals.

Lexical Scope

Most of your variables should be lexically scoped:

• my $foo;
• my $foo = 3;
• my ($foo, $bar) = (3, 4);
• my ($foo, $bar);

A lexically-scoped variable can only be used from within its enclosing block. This is like C.

• local is not my.
• You shouldn't use local, usually.
• A local variable isn't a new variable: it's a global.
• The changes to the variable are local to the block: they are reverted at the block's end.

($a, $b) = (1, 2);
sub print_ab {
	print "$a $b\n";
}
sub foo {
	local ($a) = 3;
	my ($b) = 4;
	print_ab;
}
foo;
print_ab;

Output:

3 2
1 2

A reference:

• Is a scalar
• Knows the location of some other variable

A referent (the thing to which a reference refers):

• Might not have a "real" variable name
• Will exist as long as there are any references to it

Use \ to get a reference to an existing variable (or value):

$a = "foo";
$a_ref = \$a;
@b = ('foo', 'bar');
$b_ref = \@b;

Assignment makes a copy...

...but reference assignment only copies the reference, not the referent.

Dereferencing a reference gives you the referent variable:

When you want to immediately do something with the referent, you will probably use one of these:

Index an array

$array_ref->[2]

Index a hash

$hash_ref->{'foo'}

Call a subroutine

$sub_ref->(1, 2, 3)

The familiar \ will allow us to reference a subroutine.

The subroutine can then be an argument or return value!

sub foo {
	do_something;
}
$sub_ref = \&foo;

A subroutine may access lexically-scoped variables that were valid when it was created:

sub make_adder {
	my ($a) = @_;
	return sub {
		my ($b) = @_;
		return $a + $b;
	};
}

You will often want to create an array or hash reference directly:

@a = (1, 2);
$a = \@a;

%h = (1 => 2);
$h = \%h;

$a = [1, 2];


$h = {1 => 2};

You may use a real file handle, or a reference to one, when performing input and output.

Real file handles cannot be lexically scoped, whereas references can.

For reading:

my ($fh);
open $fh, 'filename';

open my ($fh), 'filename';

For writing:

open my ($fh), '>', 'filename';
open my ($fh), '>filename';

Use the <> operator to read: <$fh>.

<> is aware of its context:

In scalar context it reads one line:

$line = <$fh>;

In list context it reads all remaining lines as a list:

@lines = <$fh>;

You can change what characters are considered end-of-line delimeters by readline:

$/ = " \t\n";
@tokens = <$fh>;

$/ = '';
$whole = <$fh2>;

Standard input's file handle is STDIN.

The <> operator defaults to reading from STDIN.

Shortcut: while (<>) means while ($_ = <>).

Use print to print:

print 'foo', 'bar', 'baz';

Print to standard output.

print $fh 'foo', 'bar', 'baz';

Print to $fh.

Special filehandles:

STDOUT

Standard output

STDERR

Standard error