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
If Test::More just isn't enough , maybe one of:
Test::Exception - Test exception based code
Test::Output - Test STDOUT and STDERR messages.
Test::DatabaseRow - Simple database tests
Test::WWW::Mechanize - Test web application
Apache::Test - Test Apache
...

? Question & Answers

http://milan.pm.org	38
http://www.linkedin.com	24
http://www.semanticwave.com	15
http://www.slideshare.net	13
http://localhost	13
http://semanticwave.com	1

Modern Perl

by Marcos Rebelo on Sep 14, 2009

Accessibility

Categories

Tags

Upload Details

Usage Rights

6 Embeds 104

Statistics

Modern Perl — Presentation Transcript