Introduction to Perl

Introductory Perl
AKA LET'S WRITE SOME FUCKING PERL
by William Orr

What do I use Perl for?
• Scripting
• Applications
• Web programming
• Pretty much everything you could want

Why?
• Perl has a very, very large set of available
libraries through CPAN
• TIMTOWTDI
• Language is very flexible - many modules on
CPAN influence behavior of language

How to get Perl - Windows
• dwimperl.com
• Comes with Padre (a Perl "IDE") as well as
tons of useful Perl modules, and an old-ish
version Strawberry Perl

How to get Perl - OSX and Linux
You already have it.

Multiple Perl Installs (you want this)
# cpan
cpan> install App::perlbrew
$ perlbrew init
$ perlbrew install perl-5.16.2
$ perlbrew switch perl-5.16.2
Install other listed modules

How to make Perl more useful
Install some modules
• App::perlbrew
• App::cpanminus
• Const::Fast
• Try::Tiny
• Devel::REPL

Documentation - perldoc
$ perldoc -f <functionname>
$ perldoc <modulename>
$ man perl

Documentation - MetaCPAN
• All the perldoc documentation online and
searchable
• Includes 3rd party docs, links to the bug
tracker, automated testing platforms, authors
website, etc.

Let's write some fucking code
use strict;
use warnings;
use v5.10;
say "WUT UP WRRRRLD";
print "WUT UP WRRRRLDn";

Let's write some fucking code
Things to notice
• use strict
• use warnings
• use v5.10
• say

Let's use some fucking variables
my $first_variable = "This is a scalar";
my $second_variable = 5;
say $first_variable;
say("This is also a scalar: $second_variable");
my $third_variable = 4.5;
say "Guess what else is a fucking scalar?
$third_variable";
my $fourth_variable = qr| d{1,2} / d{1,2} / d{2,4} |x;
say "Also a scalar: $fourth_variable";

Let's use some fucking variables
Things to notice here
• Scalars!
• Interpolation
• Parentheses are optional

Interpolation
• Variables resolve to their value in strings
quoted with "", `` and most other quote-like
operators

I want a lot of scalars!
my @lets_talk_about_arrays = ( "an", "array", "is", "a",
"set", "of", "scalars", "only");
say "@lets_talk_about_arrays";
# We can index into them!
say $lets_talk_about_arrays[1];
# We can do ranges!
say @lets_talk_about_arrays[6..7];
# We can call functions on them!
say join " ", map { uc } @lets_talk_about_arrays[6..7];
say(join(" ", map({ uc } @lets_talk_about_arrays[6..7])));

I want a lot of scalars!
Things to notice here:
• Array declaration & initialization
• Ranges with ..

How do we get array length?
my $array_size = @lets_talk_about_arrays;
say $array_size;

Context
• Functions and operators impose context on
the variables you use
• Context determines result of expression
• Three kinds of context
o scalar
o list
o void

Context
# Scalar context
my $now = localtime;
say $now;
# List context
my @now = localtime;
say "(" . join(", ", @now) . ")";

Context
To review:
• Operators and functions impose context
• Values of expression depend on context
• Arrays used in scalar context return size
• Can force scalar context with scalar()
• Can force list context with ()=
• Documentation!

Dictionar-err, hashes!
my %hash = ( key => "value", other_key => 3, "new key",
5.2 );
say %hash;
say "$hash{key}";
say "$hash{other_key}";
say "$hash{new_key}";
# Scalar context?
say scalar %hash;
# WOAH
my %empty_hash;
say scalar %empty_hash;

Let's talk about operators
• They're all pretty much the same as you're
used to!
• Except for the new ones!

New operators
• . x
• <=>
• cmp, lt, gt, lte, gte, eq, ne
• //
• =~, !~
• or, and, not, xor
• ...
open my $fh, ">", "filename" or die $@;

Control flow - loops
my @some_array = 1..10;
foreach my $iter (@some_array) {
say $iter;
}
my $done = 0;
while (not $done) {
$done = int rand 2;
say $done;
}

Control flow - if
if ($some_var ne "done") {
} elsif ($other_var == 5) {
} else {
}

Control flow - switch
given ($foo) {
when (1) {
}
when (2) {
}
when ("45hundred") {
}
default {
}
}

Special operator - ~~
• Smart match operator
• Returns true based on various, sensible
conditions
• Full table in perlsyn - /Smart matching in
detail

FUCKIT LET'S WRITE SOME
FUNCTIONS
sub my_func {
my ($first, $second, $third) = @_;
return $first + $second + $third;
}
my_func 1, 2, 3
# Array is flattened - will return 6
my @arr = (1, 2, 3, 4, 5, 6);
# NEVER &my_func

SHIT HOW DO I NOT FLATTEN
ARRAYS IN FUNCTION CALLS?!
• or also "HOW THE HELL CAN I HAVE
COMPOSITE DATA STRUCTURES?!"

Let's talk about references
• Can pass around references to _anything_
o this includes functions
• A reference is a scalar - can pop arrays into
arrays
• When you modify the value of a reference, it
modifies the original variable

my @arr = ( 1 .. 10 );
# This won't compile
#my @two_d_arr = ( @arr, @arr );
my @two_d_arr = ( @arr, @arr );
# We'll see some reference addresses
say "@two_d_arr";
# One reference address
say $two_d_arr[0];
# Dereferencing
say "@{$two_d_arr[0]}";

# Hashes?
# YOU'RE DAMN RIGHT
my %hash;
$hash{first} = @arr;
say $hash{first}->[0];
# OR
say ${hash{first}}->[0];
# Lets get fancy
$hash{second} = %hash;
say $hash{second}->{first}->[0];

sub print_shit {
say "shit";
}
$hash{third} = &print_shit;
$hash{third}->();

Anonymous references
my $arr_ref = [ 1, 2, 3, 4 ];
say @$arr_ref;
say scalar @$arr_ref;
say $arr_ref->[1]
my $hash_ref = { key => 1, other_key => 5 };
say %$hash_ref;
say $hash_ref->{key};
my $sub_ref = sub { say "foo"; }
$sub_ref->();

Anonymous references
• anonymous array references declared with []
• anon hash refs declared with {}
• anon sub refs declared with sub { }

File I/O
open(my $fh, "<", "testfile") or die "Could not open file
for reading";
foreach my $line (<$fh>) {
print $line;
}
close($fh);
open($fh, ">>", "testfile") or die "Could not open file
for writing";
say $fh "let's append a message";
close($fh);

Let's run some commands
open(my $cmd, "-|", "ls") or die "Could not run ls";
foreach my $line (<$cmd>) {
print $line;
}
close($cmd);
open($cmd, "|-", "cat") or die "Could not run cat";
say $cmd "cat'd output";
close($cmd);
my $output = qx/ls/; # `` also works
foreach my $line (split /n/, $output) {
say $line;
}

In conclusion
This is some basic Perl, and is not even close
to conclusive

Introduction to Perl

Recommended

More Related Content

What's hot (20)

Viewers also liked (11)

Similar to Introduction to Perl (20)

Recently uploaded (20)

Introduction to Perl