A brief introduction to Perl that I put together for some friends in college

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

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

3. 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

4. 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

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

6. 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

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

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

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

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

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

12. 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";

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

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

15. 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])));

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

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

18. 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

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

20. 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!

21. 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;

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

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

24. 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;
}

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

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

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

28. 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

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

30. 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

31. Let's talk about references
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]}";

32. Let's talk about references
# 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];

33. Let's talk about references
sub print_shit {
say "shit";
}
$hash{third} = &print_shit;
$hash{third}->();

34. 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->();

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

36. 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);

37. 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;
}

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