Introductory Perl
AKA LET'S WRITE SOME FUCKING PERL
by William Orr
What do I use Perl for?
Why?
How to get Perl - Windows
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
Documentation - perldoc
$ perldoc -f <functionname>
$ perldoc <modulename>
$ man perl
Documentation - MetaCPAN
Let's write some fucking code
use strict;
use warnings;
use v5.10;
say "WUT UP WRRRRLD";
print "WUT UP WRRRRLD\n";
Let's write some fucking code
Things to notice
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
Interpolation
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:
How do we get array length?
my $array_size = @lets_talk_about_arrays;
say $array_size;
Context
Context
# Scalar context
my $now = localtime;
say $now;
# List context
my @now = localtime;
say "(" . join(", ", @now) . ")";
Context
To review:
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
New operators
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 - ~~
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?!
Let's talk about references
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]}";
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];
Let's talk about references
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
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