What makes Perl … interesting?

Swap the values of two variables without using a third variable?

```
$a = "x"; $b = "y";
```
```
($b,$a) = ($a,$b);
```

data types

scalars (single values)
arrays (lists)
hashes (a.k.a. associative arrays, key-value pairs)

No other typing

no float or int or string types
no true or false
but there is undef for “undefined”
constants not provided by default
And there are modules you can include if you want these things.

OO

Object Orientation is basic
Create an object, normally a hash, and attach methods to it

package My::Module;
sub new {
	my $self   = {};
	return bless($self);
}
sub uppercase {
	my $self = shift();
	my $string = shift();
	return uc($string);
}

Sigils

each data type has its own sign or sigil at the start
```
$scalar = 'hello';
```
```
@array = ('apple','banana','cherry');
```

%hash = (code => 2000, suburb => 'CBD');

(but never store postcodes as integers, it's a terrible idea)

Brackets

brackets used for arrays and hashes are different
```
$array[2]
```
— the third item in an array
```
$hash{'postcode'}
```
— the value stored against 'postcode' in a hash

Operators are different for different things

Numbers are tested for equality with
```
==
```
and
```
!=
```
Strings are tested for equality with
```
eq
```
and
```
ne
```

Operators contd.

Numbers are compared with
```
>
```
and
```
<
```
Strings are compared with
```
gt
```
and
```
lt
```

Operators contd.

Numbers are added with +
```
$price + $surcharge;
```
Strings are concatenated with +
```
$prefix . $suffix;
```
So you can't have a 2 + 2 = 22 situation like in Javascript.

Perl has “Pronouns”

When we talk in English, we sometimes use pronouns:
“Do you know Jane?” “Yes I know her.”
“Have you read the ‘Gruffalo’ books?”
“Yes I've read them.”
Those are pronouns, because it simplifies language:
“Have you read the ‘Gruffalo’ books?”
“Yes I've read the ‘Gruffalo’ books.” Sounds strange.

Perl “Pronouns”

Perl has a variable pronoun $_ which you could translate as “it”:

foreach('apple','banana','cherry'){say $_}

There is also a array pronoun $@ which you can translate as “them”:

sub do_something{
	foreach(@_){
		say $_;
	}
}

do_something('apple','banana','cherry');

Context

perl functions “know” what context they're being called in
The localtime() function returns the time
if you call it with a scalar on the left hand side:
```
$time = localtime();
say $time;
```
you get a human-readable string:
```
Sun Jun 20 10:39:15 2021
```
but if you call it with an array on the left hand side:
```
@time = localtime();
say "@time";
```
you get an array of numbers:
```
(15, 39, 10, 20, 5, 121, 0, 170, 0)
```

“Unnecessary” keywords

Perl obviously has the "if" keyword:
```
if($something){ do_something() }
```
But it also has the “unless” keyword:
```
unless($something){ do_something() }
```
It's exactly the same as
```
if( ! $something ){ do_something() }
```
But the fact that it exists allows coders to do things their own way.
There's also an inverse for while(), the until() keyword.

Flexibility

Extreme flexibility is a feature of Perl
All of these work:
```
print $foo if $bar;
```
```
if ($bar) {print $foo;}
```
```
$bar && print $foo;
```
```
print $bar ? $foo :'';
```

Flexibility is part of perl culture

The expression “There Is More Than One Way To Do It” is a perl catchphrase
Sometimes “TIMTOWTDI”
But just because you can write perl in extreme shorthand and unusual ways…
… doesn't mean you're encouraged to do so.
All perl programs should start with
```
use strict;
```
and
```
use warnings;
```
These force you to declare all variables in the right scope and warn about errors.

Perl documentation encourages good code

Perl is “postmodern”

“one of the characteristics of a postmodern computer language is that it puts the focus not so much onto the problem to be solved, but rather onto the person trying to solve the problem. […] I claim that it was the first computer language to do that. I'd also like to claim that, in many ways, it's still the only language to do that.

How does Perl put the focus onto the creativity of the programmer? Very simple. Perl is humble. It doesn't try to tell the programmer how to program.” — Larry Wall

Unusual features of Perl

Even punctuation is flexible

```
print "postcode: $postcode";
```
but if you want quotes inside your quoted string:
```
print "postcode: \"$postcode\"";
```
there's a quote operator:
```
print qq(postcode: "$postcode");
```

but what if you have brackets as well?:

print qq(postcode (for Campsie): "$postcode");

the qq operator can use any kind of 'brackets' you like:

any one of these will work:

qq[]; qq##; qq//; qq\\; qq{}; qq^^; qq!!; qq--;

punctuation contd.

punctuation can often be skipped

push(@array,$variable);
push @array, $variable;

Though not that semicolon

“Auto-vivification”

Create an array and an element in it in one step:

# @array does not exist yet.
$array[3] = 'Durian';

Now the array exists and contains
```
 [ undef, undef, undef, 'Durian' ];
```

Incrementing strings

```
$a = 1;
$a++;
```
Now of course $a contains 2;
But what about this:
```
$a = 'A';
$a++;
```
Now $a contains B

$a = 'Z';
$a++; # what does $a contain now?

Now $a contains AA

Regular Expressions

Perl is known for having powerful regular expressions
regular expressions are built in to the language, not functions or an imported library
regular expressions act directly on the variable

$str = 'the cat sat on the mat';
$str =~ s/cat/dog/;

Now the $str variable contains 'the dog sat on the mat'

Regular Expressions contd.

The replacement section on the right hand side of a perl regex can be executable

$str = 'the cat sat on the mat';
$str =~ s/cat/uc($&)/e;

Now the $str variable contains 'the CAT sat on the mat'

Substrings

Most languages allow you to get a substring:

$str = 'the cat sat on the mat';
$animal = substr($str,4,3);

Perl lets you set a substring:

$str = 'the cat sat on the mat';
substr($str,4,3) = 'goat';

Now $str is 'the goat sat on the mat' even though the numbers don't add up

Data and script together

This is how we read data in from an external file:

open(FILE,'<','/var/log/some.log');
while(<FILE>){
	do_something();
}

Data and script contd.

But you can also do this:

# we don't open an external file
while(<DATA>){
	do_something();
}
# so where's the file?




__DATA__
suburb,postcode
Campsie,2194
Canterbury,2193
Pyrmont,2009

Questions?

Or a game of “will this code run in Perl?”