Modern Perl

use v5.10;

say

The usual:

print "Hello, World! ";
print my_sub_call(...), " ";

or:

say 'Hello, World!';
say my_sub_call(...);

Defined or

The usual: $name = 'oleber' if not defined $name;
or $name // = 'oleber';

switch

if ($value =~ /pippo/) { ... } elsif ($va1ue eq 'alpha') { ... } elsif ($value == 1 or $value == 2 ) { ... } else { ... }

switch

given ($value) { when (/pippo/) { ... } when ('alpha') { ... } when ([1,2]) { ... } default { ... } }

Smart matching

The usual: if ( grep {/pippo/} @array ) { … }
or if ( @array ~~ /pippo/ ) { … }

state

the usual { my $static_var = 0; sub xpto { ... } }
or sub xpto { state $static_var = 0; ... }

New RegExp

Named Capture Buffers 'Michael Jackson' =~ /( ?<fn> .*)s( ?<ln> .*)/; %+ is ('fn'=>'Michael', 'ln'=>'Jackson'}
"K" escape, floating length positive lookbehind: s/(foo)bar/$1/g becomes s/fooKbar//g
Backtracking control verbs
...

Object Oriented

use Moose; package Person; use Moose; # now it's a Moose class! # imports strict and warnings ... no Moose ; __PACKAGE__->meta->make_immutable ;

Moose attributes has id => ( is => 'ro' , isa => 'Int' , ); has name => ( is => 'rw' , isa => 'Str' , ); my $person = new Person(id => 123, name => ' John '); $person->name('peter'); # OK $person->id(12); # NOK

Moose Types

Many types are already defined like:

Num, Int, Str, ClassName, Ref, ScalarRef, ...

Even some parameterized

ArrayRef[Int] # an array of integers
HashRef[CodeRef] # a hash of str to Code ref
...

Define your types use Moose::Util::TypeConstraints; subtype 'Telephone' => as 'Str' => where { $_ =~ /^d+$/}; no Moose::Util::TypeConstraints; has telephone => ( is => 'rw', isa => 'Telephone' , ); $person->telephone('35196219374'); # OK $person->telephone('XPTO'); # NOK

Moose class Inheritance package User; use Moose; extends 'Person'; has login => ( is => 'rw', isa => 'Str', ); ... my $user = new User(id => 52, login => 'oleber')

Moose Method sub do_login { my ($self, $password) = @_; ... }

Moose method modifiers before do_login => sub { my ( $self, $pass ) = @_; warn "Called login() with $pass "; }; around name => sub { my ($orig, $self, @args) = @_; return ucfirst lc $self->$orig( @args ) ; }; ...

Moose Constructor

The new() method is created for you, and it simply does the right thing.

You should never need to define your own new() constructor!!!

You can provide a BUILD() method in your class. Moose will call this for you after creating a new object.

Moose Destructor

If you really need it in Perl ...
The old DESTROY is used internally by Moose
You shall use the DEMOLISH() method

Call methods on native types

autobox use JSON; say to_json [ map { $_ ** 2 } @array ]; use autobox; local *ARRAY::map = sub { my ( $self, $block ) = @_; return [map {&$block($_)} @$self ]; }; local *ARRAY::to_json = sub { return to_json(shift); }; say @array->map( sub { $_ ** 2 } )->to_json;

autobox

It allows methods to be called on integers, floats, strings, arrays, hashes, and code references in exactly the same manner as blessed references.

"hello world!"->upper() is equivalent to SCALAR::upper("hello world!")
[1..10]->foreach(sub { ... }) resolves to: ARRAY::foreach([1..10], sub { ... })

autobox

The autobox module gives the illusion that Perl's types are first-class objects.
Cpan has already some Packages with the most logical functions implementation. See:

autobox::Core
Moose::Autobox

Exception handling

Error use Error qw(:try); try { throw ...; } catch Error::IO with { my $E = shift; warn "File $E->{'-file'} had a problem "; } except { my $E = shift; warn "ERROR: " . Dumper $E; } otherwise { say "ALL OK "; } finally { say "Finished" } ; # Don't forget the trailing ;

TryCatch use TryCatch; try { die ... } catch ( PKG_1 $e where { $_->code > 100 } ) { ... } catch ( PKG_2 $e ) { ... } catch ( $e ) { ... } catch { ... }

It is better to die() than to return() in failure. (Paul Fenwick) The Box Jellyfish Saltwater Crocodile Blue Ring Octopus Stone fish Red Back Spider Funnel Web Spider

autodie open(my $FH, ">>", $path) or die "Can't open $!"; system($cmd) == 0 or die "system failed: $?"; if ( defined ( my $pid = fork() ) ) { if ( $pid != 0 ) { # parent } else { # child } } else { die "Can't fork"; }

autodie use autodie qw(:all); open(my $FH, ">>", $path) or die "Can't open $!"; system($cmd) == 0 or die "system failed: $?"; if ( defined ( my $pid = fork() ) ) { if ( $pid != 0 ) { # parent } else { # child } } else { die "Can't fork"; }

autodie use autodie qw(:all); open(my $FH, ">>", $path); system($cmd) == 0 or die "system failed: $?"; if ( defined ( my $pid = fork() ) ) { if ( $pid != 0 ) { # parent } else { # child } } else { die "Can't fork"; }

autodie use autodie qw(:all); open(my $FH, ">>", $path); system($cmd); if ( defined ( my $pid = fork() ) ) { if ( $pid != 0 ) { # parent } else { # child } } else { die "Can't fork"; }

autodie use autodie qw(:all); open(my $FH, ">>", $path); system($cmd); if ( ( my $pid = fork() ) != 0 ) { # parent } else { # child }

autodie error analyse eval { use autodie; open(my $FH, '<', $some_file); while ( my $line = readline $FH ) { ... } close($fh); }; given ($@) { when (undef) { say "No error"; } when ('open') { say "Error from open"; } when (':io') { say "Non-open, IO error."; } when (':all') { say "autodie error." } default { say "Not an autodie error." } }

autodie vs Fatal autodie

Lexical scope
Better Errors

Fatal

Package scope
Crazy Errors

Good Coding Style

Perl Best Practices

Good Coding Style

Three Goals to be achieved :

Robustness: reduce the number of bugs.
Efficiency: faster code.
Maintainability: help you to enter "in the zone".

Suggestions (not commandments) can be found in:

Damian's book Perl Best Practices
perldoc perlstyle

Perltidy

Code Layout

indents.
reformats.

Very configurable Perl script that default to the perlstyle Layout

Perlcritic

Perl source code analyze witch attempts to identify:

awkward code
hard to read code
error-prone code
unconventional constructs

Most of the rules are based on Damian Conway's book Perl Best Practices

Unit test

Test::Simple use Test::Simple tests => 2; ok ( 1 + 1 == 2, "sum" ); ok ( 2 * 3 == 5, "multiplication"); prints: 1..2 ok 1 - sum not ok 2 - multiplication # Failed test 'multiplication' # at script.t line 6. # Looks like you failed 1 test of 2.

Test::More Complex stuff use Test::More 'no_plan'; ok ( 1 + 1 == 2, "sum" ); is ( 1 + 1, 2, 'add'); isnt ( 2 * 3, 5, 'multiplication'); is_deeply ({1..4}, {1=>2, 3=>4}, "similar hash"); my $str = 'Hello, World!'; like ($str, qr/Hello/, 'match'); unlike ($str, qr/Dude/, 'No way Dude'); use_ok ('Person'); can_ok ('Person', 'name'); ...

More specific tests