Pit2012 modern perl

PIT 2012: Workshop@UniNA
Introduzione a Modern::Perl
- a cura di Mario Rossano aka Anak -
con il patrocinio del Preside della Facoltà di Ingegneria
dell'Università degli Studi di Napoli Federico II:
Prof. Piero Salatino
e con il sostegno del Prof. Antonio Pescapè
Comics Unina Research Group
Facoltà di Ingegneria, Univ. Federico II di Napoli, 14/05/2012

di Mario Rossano aka Anak – anak@cpan.org
• Il linguaggio Perl

• Struttura dei dati (variabili)
• Variabili speciali

• Sintassi

• Sintassi
• Gli operatori: logici e comparativi
• Altri operatori, numerici e funzioni
• Le istruzioni condizionali
• Iteratori
• Controllo sui cicli

• Sintassi
Gli operatori: logici e comparativi
Altri operatori, numerici e funzioni
• Iteratori
• Input/Output

• Sintassi
• Iteratori
• Input/Output
• Espressioni regolari

• Sintassi
• Iteratori
• Input/Output
• Subroutine

• Sintassi
• Iteratori
• Input/Output
• Subroutine
• Package e Moduli

• Sintassi
• Iteratori
• Input/Output
• Subroutine
• Programmazione ad oggetti

• Sintassi
• Iteratori
• Input/Output
• Subroutine
• Database

• Sintassi
• Iteratori
• Input/Output
• Subroutine
• Database
• CPAN e moduli di rilievo

• Sintassi
• Iteratori
• Input/Output
• Subroutine
• Database
• Modern::Perl

•
Il linguaggio Perl

•
Il linguaggio Perl
PERL → Pratical Extraction and Report Language

•
Il linguaggio Perl
PERL → Pathologically Eclectic Rubbish Lister

•
Il linguaggio Perl
PERL → Polomorphic Existential Recursive Lambdas

•
Il linguaggio Perl
PERL

•
Il linguaggio Perl
PERL
Perl

•
Il linguaggio Perl
PERL
Perl
È il nome del linguaggio, non un acronimo

•
Il linguaggio Perl
Come ha detto Larry Wall (creatore del Perl):
”There is More Than One Way To Do It”
”C'è più di un modo per farlo”

•
Il linguaggio Perl
Perl permette una notevole libertà espressiva, simile al linguaggio naturale.

•
Il linguaggio Perl
E' possibile integrare codice scritto in C ed in altri linguaggi, tramite i moduli Inline::*

•
Il linguaggio Perl
E' possibile integrare codice scritto in C ed in altri linguaggi, tramite i moduli Inline::*
Non è interpretato, bensì trasformato in bytecode che viene poi eseguito.

•
Il linguaggio Perl
Sui sistemi *NIX è quasi certamente già installato (99.99%), diversamente:
apt-get install perl

•
Il linguaggio Perl
Sui sistemi *NIX è quasi certamente già installato (99.99%), diversamente:
apt-get install perl
Su Windows sono disponibili:
Activestate Perl → http://www.activestate.com/activeperl
Strawberry Perl → http://strawberryperl.com/

•
Il linguaggio Perl
Per avere un aiuto:

•
Il linguaggio Perl
Per avere un aiuto:
perldoc ($ apt-get install perl-doc)
mongers@perl.it (mailing list)

•
Il linguaggio Perl
Per avere un aiuto:
#perl.it (irc su freenode.net)

•
Il linguaggio Perl
Per avere un aiuto:
#perl.it (irc su freenode.net)
www.perlmonks.org

•
Sintassi
Perl ha una sintassi derivata dal linguaggio C
I blocchi sono delimitati da parentesi graffe {
Il delimitatore di fine istruzione è il punto e virgola ;
Perl ha una sintassi derivata dal linguaggio C
BLOCK {
… ;
… ;
...
}

•
Struttura dei dati

•
Struttura dei dati
In Perl i nomi delle variabili sono preceduti da un carattere detto: SYGIL

•
Struttura dei dati
Ci sono tre SYGIL e riflettono la struttura della variabile:

•
Struttura dei dati
$ → scalare

•
Struttura dei dati
$ → scalare
@ → array

•
Struttura dei dati
$ → scalare
@ → array
% → hash

•
Struttura dei dati
$ → scalare → può contenere un singolo valore di qualunque tipo (stringa, nun, ...)
@ → array
% → hash

•
Struttura dei dati
@ → array →può contenere una lista ordinata di scalari
% → hash

•
Struttura dei dati
@ → array →può contenere una lista ordinata di scalari
% → hash → associa una lista non ordinata di chiavi (stringa) a scalari, array o hash

•
Struttura dei dati: esempi

•
$scalare=7;
$scalare='NaLUG';
$scalare='7';
$scalare=1.32e-10;
$scalare=0xdeadbeaf;
$scalare=0b0001010;

•
$scalare=7;
$scalare='NaLUG';
$scalare='7';
$scalare=1.32e-10;
$scalare=0b0001010;
@array=(7,'NaLUG','7',1.32e-10,0xdeadbeaf,0b0001010);
@array = ( [1, 2, 3],
[4, 5, 6],
[7, 8, 9]
);

•
$scalare=7;
$scalare='NaLUG';
$scalare='7';
$scalare=1.32e-10;
$scalare=0b0001010;
@array=(7,'NaLUG','7',1.32e-10,0xdeadbeaf,0b0001010);
$array[0] → 7; $array[1] → 'Nalug';...
@array = ( [1, 2, 3],
[4, 5, 6],
[7, 8, 9]
);
$array[0][0] → 1; $array[1][2] → 6;
%hash={...}

•
my $scalare="prova";
my @array=(0,1,2);
my %hash=(
chiave1 => 'stringa',
chiave2 => $scalare,
chiave3 => [@array],
chiave4 => [0,2,'testo'],
chiave5 => [
{
flintstones => 'Fred',
goldrake => ['Actarus','Alcor']
},
],
);

•
my $scalare="prova";
my @array=(0,1,2);
my %hash=(
chiave1 => 'stringa',
chiave2 => $scalare,
chiave3 => [@array],
chiave4 => [0,2,'testo'],
chiave5 => [
{
flintstones => 'Fred',
goldrake => ['Actarus','Alcor']
},
],
);
say $hash{'chiave1'};
stringa
say $hash{'chiave3'}[1];
1
say $hash{'chiave4'}[2];
testo
say $hash{'chiave5'}[0]{flintstones};
Fred
say $hash{'chiave5'}[0]{goldrake}[1];
Alcor

•
Struttura dei dati: funzioni su array ed hash
pop ARRAY → rimuove e restituisce l'ultimo valore dell'array
push ARRAY,LISTA → aggiunge alla fine di array i valori di lista
shift ARRAY → rimuove e restituisce il primo elemento di array
splice ARRAY,SCOSTAMENTO, LUNGHEZZA,LISTA → rimuove da ”array” a partire da
”scostamento” per la ”lunghezza” e li sostituisce (se ci sono) con quelli di ”lista”.
Se ”scostamento” è negativo, l'operazione è fatta a partire dalla fine dell'array
join ESPR,LISTA → trasforma una lista o un array in una stringa, con gli elementi
separati da ”espr”

•
Struttura dei dati: funzioni su array ed hash
sort LISTA → effettua un ordinamento dei dati
sort{$a cmp $b} @file # lessicale
sort{$a <=> $b} @file # numerico
reverse LISTA → capovolge una lista
keys HASH → restituisce un array contenente le chiavi dell'hash
values HASH → restituisce un array contenente i valori dell'hash
my %settimana=(
'Lun' => 'Mon',
'Mar' => 'Tue',
'Mer' => 'Wed',
'Gio' => 'Thu',
'Ven' => 'Fri',
'Sab' => 'Sat',
'Dom' => 'Sun'
)
Es.
foreach $chiave(keys(%settimana)) {
say ”$settimana{$chiave}”
}

•
Struttura dei dati: variabili speciali – v.http://perldoc.perl.org/perlvar.html
$_ → contiene il default input. Ad es. In un ciclo, se non specificato diversamente
Perl usa $_ come valore. for (1..20) say $_;
$PROCESS_ID or $PID or $$ → numero del processo in cui gira il Perl script
$PROGRAM_NAME or $0 → nome del programma in esecuzione
$a e $b → quando sono usate nella funzione sort, non vanno dichiarate
@ARGV → array degli argomenti passati allo script da shell
$OSNAME or $^O → nome OS su cui gira Perl
$PERL_VERSION or $^V→ versione di Perl in esecuzione
$ERRNO or $! → contiene informazioni sull'errore di esecuzione

Operatori logici binari
AND bassa priorità → &&
AND alta priorità → and
OR bassa priorità → || (ASCII 124)
OR alta priorità → or
XOR bassa priorità → ^
XOR alta priorità → xor
Operatore logico unario
NOT bassa priorità → !
NOT alta priorità → not
• Sintassi: gli operatori logici e comparativi

• Sintassi: gli operatori logici e comparativi
Operatori di comparazione
Numeri Stringhe
> gt maggiore di
>= ge maggiore o uguale di
< lt minore di
<= le minore o uguale di
== eq uguale a
!= ne diverso
<=> cmp comparazione, ritorna -1, 0 oppure 1
Es. $a<=>$b
Se $a<$b → -1 se $a=$b → 0 se $a>$b → 1

• Sintassi: altri operatori, numerici e funzioni
Operatori numerici
Addizione +
Sottrazione -
Moltiplicazione *
El. a potenza **
Funzioni matematiche (altre su mod. Math::Trig;)
Valore assoluto abs
Arcotangente atan2
Coseno cos
Esponenziale exp
Esadecimale hex → hex '0xAf' stampa '175'
Parte intera int → non arrotonda
Logaritmo nat. log → in b.10 log($n)/log(10)
Ottale oct
Random rand
Seno sin
Radice quadrata sqrt (Math::Complex per i neg.)

• Sintassi: altri operatori, numerici e funzioni
Operatori stringa
Concatenazione .
Funzioni su stringhe (principali)
chomp ($s)→ rimuove il newline in coda
chop ($s) → rimuove l'ultimo carattere
chr ($n) → restituisce il carattere nell'insieme
length ($s) → lunghezza della stringa
reverse ($s) → inverte la stringa
substr ($s,start,end) → estrae una sottostringa

If LOGICAL {
BLOCK
} elsif LOGICAL {
BLOCK
} else {
BLOCK
}
switch LOGICAL
case BLOCK
case …
else ...
If LOGICAL ? BLOCK : BLOCK
BLOCK if LOGICAL
given ($scalar) {
when (/apples/) { BLOCK}
when …
default { BLOCK}
}

• Gli iteratori
for → for (my $counter=0;$counter<=$numerical;$counter++) {BLOCK}
→ for (0..$numerical) {BLOCK}
my @lista;
for LISTA {BLOCK} → for @lista {BLOCK}
foreach LISTA {BLOCK} → foreach my $lista(@lista)
”c'è più di un modo per farlo”

• Cicli condizionali
while LOGICAL {BLOCK} → siamo dentro finché condizione è TRUE
until LOGICAL {BLOCK} → siamo dentro finché condizione è FALSE
do {BLOCK} while LOGICAL → siamo dentro finché condizione è TRUE
do {BLOCK} until LOGICAL → siamo dentro finché condizione è FALSE
do → garantisce che il ciclo verrà eseguito almeno una volta

•
Controllo sui cicli
Sono interni al blocco e si applicano a tutti i cicli. Permettono di variare il
comportamento del blocco senza intervenire sulla condizione di entrata.
next
redo
last

•
Controllo sui cicli
next → salta una iterazione del ciclo
esempio: next if $salta eq 'true';
redo
last

•
Controllo sui cicli
redo → ripete ”lo stesso” ciclo senza modificare la condizione di entrata
esempio: redo if $ripetimi eq 'true'; # non modifica i contatori
last

•
Controllo sui cicli
redo → ripete ”lo stesso” ciclo senza modificare la condizione di entrata
esempio: redo if $ripetimi eq 'true'; # non modifica i contatori
last → termina immediatamente il ciclo
esempio: last if $interrompi eq 'true';

• Input/Output SU FILE
Modalità di apertura:
open my $fileHandle,MODE,$fileName or die !$
< → lettura (default)
> → scrittura (crea/sovrascrive il file)
>> → append
+> → lettura e scrittura (crea/sovrascrive il file)
+< → lettura e scrittura
+>> → append e lettura
Chiusura:
close $fileHandle;

• Input/Output SU FILE
Lettura di un file:
while (!eof($fileHandle)) {
my $riga=<$fileHandle>;
…
...
}
Scrittura in un file:
print $fileHandle $qualchecosa.”n”

• Le espressioni regolari (REGEXP)
L'arma letale di Perl è un linguaggio nel linguaggio.
A cosa servono le espressioni regolari:
. verificare la presenza di una stringa in un'altra
. sostituire in un testo una parte di stringa con altra stringa

Matching: my $scalare =~ /regexp/
Substitution my $scalare =~ s/$scalare1/$scalare2/
Sintassi regexp:
^ inizio stringa
$ fine stringa
(…) gruppo caratteri
[a-zA-Z] classe caratteri
. jolly → qualsiasi carattere
/g → globale

Quantificatore Descrizione
* Trova 0 o più volte (massimale)
+ Trova 1 o più volte (massimale)
? Trova 1 o 0 volte (massimale)
{n} Trova esattamente n volte
{n,}Trova almeno n volte (massimale)
{n,m} Trova almeno n volte ma non più di m volte (massimale)
*? Trova 0 o più volte (minimale)
+? Trova 1 o più volte (minimale)
?? Trova 1 o 0 volte (minimale)
{n,}? Trova almeno n volte (minimale)
{n,m}? Trova almeno n volte ma non più di m volte (minimale)

Caratteri speciali 1/2
0 Trova il carattere NULL (ASCII 0)
NNN Trova il carattere indicato, in notazione ottale, fino a 377
a Trova il carattere BEL (quello che fa suonare lo speaker)
b Trova il carattere BS (backspace)
cX Trova il carattere CTRL-X (es.: cZ trova CTRL-Z)
d Trova un numero
D Trova un non-numero
e Trova il carattere ESC (escape, da non confondersi col backslash)
f Trova il carattere FF (form feed)
n Trova il carattere NL (new line, CR sui Macintosh)
r Trova il carattere CR (carriage return, NL sui Macintosh)

Caratteri speciali 2/2
s Trova uno spazio (spazio, HT, NL, CR, FF)
S Trova un non-spazio
t Trova il carattere di tabulazione (HT)
w Trova un carattere alfanumerico più l'underscore (_)
W Trova un carattere che non sia un alfanumerico o un underscore
x Trova i carattere indicato, in notazione esadecimale
i case insensitive
g globale (non esce al primo match)

Per effettuare il matching di caratteri speciali (ad es. $, |, [, ), , /)
occorre farli precedere da backslash:
| # barra verticale
[ # quadra aperta
) # tonda chiusa
* # asterisco
^ # carat
/ # slash)
# backslash

Esempi:
$testo='Anak dice: Trovami al PIT2012';
if ('trovami' =~ /$testo/i) {BLOCK}
$testo =~ s/trovami/è andato/i; → Anak dice: è andato al PIT2012
if ($testo =~ /^Anak/) {BLOCK}; → vero perchè $testo inizia con Anak
$filename='PIT2012.pdf';
If ($filename =~ /.[a-zA-Z]{3}$/) {BLOCK} → vero, estensione 3 char
Verifica sintattica indirizzo email;
/^([w-+.]+)@([w-+.]+).([w-+.]+)$/

• Le subroutine
Il pilastro della programmazione strutturata
DRY: Dont Repeat Yourself
Ogni qualvolta abbiamo una ripetizione di codice è il segno che
dovremmo implementare una subroutine.

• Le subroutine
Sygil &

• Le subroutine
Sygil &
sub mySubroutine(PARAMETER,...) {BLOCK}
Invocazione: &mySubroutine
Come function: my $scalar or @array or %hash = mySubroutine(...);

I package sono collezioni di subroutine.
Mentre le subroutine permettono di organizzare blocchi di codice, i package
Spingono questa granularità ad un livello più alto.

foreach my $element(@array) {
BLOCK
}
{
package nalug;
my $variabileInterna=...;
Sub nameSubroutine BLOCK
}
my $result=nalug::nameSubroutine();
my $variabileEsterna=$nalug::variabileInterna;

I moduli contengono package.
Mentre le subroutine permettono di organizzare blocchi di codice ed i package
spingono questa granularità ad un livello più alto, i moduli contengono package
e costituiscono files esterni al nostro script.

I moduli contengono package.
Mentre le subroutine permettono di organizzare blocchi di codice ed i package
spingono questa granularità ad un livello più alto, i moduli contengono package
e costituiscono files esterni al nostro script.
Istruzione ”use” seguita dal nome qualificato del modulo
use Crypt::FNA;

I moduli pragmatici – usa Perl responsabilmente!
use strict;
use warnings;

use strict;
use warnings;
strict → attiva controlli sullo scope delle variabili e la loro definizione.
Obbliga, ad es. all'uso di ”my”

use strict;
use warnings;
strict → attiva controlli sullo scope delle variabili e la loro definizione.
Obbliga, ad es. all'uso di ”my”
warnings → indica errori non fatali ma che è bene controllare

Usiamo elementi già noti del linguaggio:
Oggetti → Riferimenti

Classi → Package

Classi → Package
Metodi → Subroutine

Classi → Package
D. Come creo un oggetto?

Classi → Package
D. Come creo un oggetto?
R. Lo battezzo come tale.

sub new {
my $class = shift;
my $init = shift;
my $self={};
bless $self,$class;
$self->nome($init->{number})
return $self
}
#costruttore
package Qualche::Cosa;

sub new {
my $class = shift;
my $init = shift;
my $self={};
bless $self,$class;
$self->nome($init->{number})
return $self
}
sub nome {
my $self=shift;
if (@_) {
$self->{nome}=shift
}
return $self->{nome}
}
Package Figlio;
use base Qualche::Cosa;
#costruttore #attributi

Non serve, lo ha già creato
Class::Accessor;
Qualche::Cosa->mk_accessors(qw(nome ...));
#costruttore (new) #attributi
use base Class::Accessor;

Class::Accessor;
Scrivere meno codice permette di compiere meno errori e di rendere efficiente
la lettura e manutenibilità.

Class::Accessor;
Scrivere meno codice permette di compiere meno errori e di rendere efficiente
la lettura e manutenibilità.
Ancora non abbiamo un sistema di coerenza dei valori degli attributi a meno di
Programmarlo. Vediamo se c'è di meglio...

La via della Forza: Moose
È un modulo che implementa OOP e semplifica la creazione/gestione di oggetti
Per creare un oggetto sarà sufficiente:
package ilMioOggetto;
use Moose;
...e basta! Moose crea il costruttore new() così come Class::Accessor ma...

Possiamo definire gli attributi specificandone il tipo.
Es.
use Moose;
has 'nome' => (
is => 'rw',
isa => 'Str'
)

E tanto altro ancora come la possibilità di estendere la superclasse,
definire ruoli e tanto altro ancora.
Moose ”base” è dotato di numerosissime classi che ne estendono ulteriormente
le già notevoli capacità.
v.
http://search.cpan.org/~doy/Moose-2.0602/lib/Moose/Manual.pod

Esempi: istanziare un oggetto da script
use ANM::Info;
my $numero_palina='2501';
my $palina=ANM::Info->new({number => $numero_palina});
say ”$palina->get_info”;
#---------------------------------------------------------------------------------
use Crypt::FNA;
my $krypto=Crypt::FNA->new();
$krypto->encrypt_file('presentazione.pdf','presentazione.fna');

• Database
use DBI; # DataBase Interface

• Database
espone un'interfaccia ad oggetti
# istruisce su tipo database, nome ed host
my $dsn="DBI:mysql:database=$dbname;host=$host";
# effettua la connessione
my $dbh=DBI->connect($dsn,$user,$pass) or die (
"Couldn't connect to database: ".DBI->errstr
);
$dbh->{AutoCommit} = 0

• Database
Preparazione ed esecuzione di una query SQL
my $sth = $dbh->prepare(qq{
SELECT product_id
FROM jos_vm_product
WHERE product_sku=?}
) or die $dbh->errstr;
$sth->execute($codice);

• Database
Lettura dei risultati della query
while (my $row=$sth->fetchrow_hashref()) {
say ”$row{fieldName}”
}
Il metodo fetchrow_hashref restituisce la tabella con i risultati in un hash
Ci sono poi molti altri metodi selectrow_array, selectrow_arrayref,
selectall_hashref, selectcol_arrayref, ecc.

CPAN → Comprehensive Perl Archive Network
Stop reinventing wheels, start building space rockets

Cosa è? E' l'archivio mondiale di riferimento dove trovare classi per ogni
esigenza, suddivise per categoria

Perchè? Reinventare la ruota non è ”perlish”, mentre lo è costruire
implementando altre classi così da realizzare soluzioni anche
complesse con una curva di sviluppo rapida senza perdere in
qualità :)

Perchè? Reinventare la ruota non è ”perlish”, mentre lo è costruire
implementando altre classi così da realizzare soluzioni anche
complesse con una curva di sviluppo rapida senza perdere in
qualità :)
Come? La qualità è una condizione necessaria: perchè una classe sia
pubblicata su CPAN occorre scrivere ”strict”; fornire puntuale
documentazione a corredo; superare i test dei CPAN Testers...

CPAN Testers → Mettono a disposizione delle macchine, sui più disparati OS
e mediante procedure automatiche verificano l'esecuzione
della classe, riportando errori, warnings, difetti nella
documentazione, segnalandoli all'autore
URL: metacpan.org
cpantesters.org

CPAN Testers
Forniscono all'autore e allo
sviluppatore che usa una classe
l'indicazione di eventuali
problemi, con particolare
riferimento all'OS usato, alla
versione di Perl utilizzata, alla
versione della classe.
Tutti i dati sono pubblici.
Chiunque può partecipare al
progetto e diventare CPAN
Tester.

Come installo un modulo sul mio computer?
$ cpan -i Crypt::FNA

E se ci sono dipendenze da altre classi?

Le risolve cpan automaticamente, grazie alle informazioni che sono rese
obbligatorie agli autori da CPAN.

E se il mio script lavora in remoto e non posso accedere alla shell?

Ci sono diverse soluzioni. Una è quella di caricare in remoto le classi da cui
dipende la nostra, istruendo il nostro script del percorso in cui trovarle.

Ci sono diverse soluzioni. Una è quella di caricare in remoto le classi da cui
dipende la nostra, istruendo il nostro script del percorso in cui trovarle.
use lib qq($ENV{DOCUMENT_ROOT}/lib);

•
CPAN e moduli di rilievo

•
Parsing XML
use strict;
use warnings;
use XML::Simple;
use Data::Dumper;
my $config_filename = 'config.xml';
my $config = XMLin($config_filename);
print Dumper($config); # il risultato sarà in un hash

•
Parsing URI
use strict;
use warnings;
use feature 'say';
use URI;
my $uri = URI->new('http://www.nalug.net/index.php');
say ”Protocollo: ” . $uri->scheme; # http
say ”Host: ” . $uri->host; # www.nalug.net
say ”Path: ” . $uri->path; # /index.php

•
Parsing directory in modo ricorsivo
use strict;
use warnings;
use feature 'say';
use File::Find;
my $top_directory='.'
find(&wanted, $top_directory);
sub wanted () {
say $File::Find::name; # variabile package, contiene il nome della dir parsata in quel ciclo
}

•
Parsing directory in modo ricorsivo
use Modern::Perl;
use File::Find;
find({wanted=> sub{say $File::Find::name}},'.');
In modo più compatto, con l'ausilio di una sub anonima

•
Upload e download su FTP
use strict;
use warnings;
use Net::FTP;
$ftp = Net::FTP->new($host, Debug => 0 , Passive => 0) or die "errore $@";
$ftp->login($user,$password) or die "Non riesce il login ", $ftp->message;
$ftp->put($filename) or die "upload fallito ", $ftp->message;
$ftp->get($filename) or die "download fallito ", $ftp->message;
$ftp->quit;

•
Invio e ricezione email
use Modern::Perl;
use Net::SMTP;
$smtp = Net::SMTP->new($host,Timeout => 60);
$smtp->auth($user,$password);
$smtp->mail($sender);
$smtp->to($receiver);
$smtp->data();
$smtp->datasend("To: postmastern");
$smtp->datasend("n");
$smtp->datasend("A simple test messagen");
$smtp->dataend();
$smtp->quit;

•
Invio e ricezione email
use Modern::Perl;
use Net::POP3; # c'è anche Net::IMAP
$pop = Net::POP3->new('pop3host', Timeout => 60);
if ($pop->login($username, $password) > 0) {
my $msgnums = $pop->list; # hashref di msgnum => dimensione
foreach my $msgnum (keys %$msgnums) {
my $msg = $pop->get($msgnum);
print @$msg;
$pop->delete($msgnum);
}
}
$pop->quit;

•
Comunicare con un webserver
use Modern::Perl;
use LWP::UserAgent;
my $ua = LWP::UserAgent->new;
$ua->timeout(10);
# lettura
my $response = $ua->get('http://www.nalug.net/');
if ($response->is_success) {
print $response->decoded_content; # or whatever
} else {
die $response->status_line
}

•
Comunicare con un webserver
use Modern::Perl;
use LWP::UserAgent;
my $ua = LWP::UserAgent->new;
$ua->timeout(10);
# lettura del risultato inviando parametri in post
my res=$ua->post(
SERVER_ANM,
Content => {
__VIEWSTATE => VIEWSTATE_VALUE,
__EVENTVALIDATION => EVENTVALIDATION_VALUE,
TxTNumeroPalina => $self->number,
BtnInviaDati => 'Invia Dati'
}
);

•
Gestire PDF: dato un modello di documento PDF, potrete scrivervi dentro
use Modern::Perl;
use PDF::Reuse;
prFile('myFile.pdf');
prText(100, 500, 'Hello World !');
prEnd();

•
Leggere e scrivere file XLS
# come database → DBD::Excel e quindi il modulo DBI

•
use Spreadsheet::ParseExcel;
my $parser = Spreadsheet::ParseExcel->new();
my $workbook = $parser->parse('Book1.xls');
for my $worksheet ( $workbook->worksheets() ) {
my ( $row_min, $row_max ) = $worksheet->row_range();
my ( $col_min, $col_max ) = $worksheet->col_range();
for my $row ( $row_min .. $row_max ) {
for my $col ( $col_min .. $col_max ) {
my $cell = $worksheet->get_cell( $row, $col );
next unless $cell;
say "Row, Col, Value = ($row, $col) $cell->value()";
}
}
}

•
use Spreadsheet::WriteExcel;
my $workbook = Spreadsheet::WriteExcel->new('nalug.xls');
# Add a worksheet
$worksheet = $workbook->add_worksheet();
# Add and define a format
$format = $workbook->add_format();
$format->set_bold();
$worksheet->write($row, $col, 'W il NaLUG', $format);
$worksheet->write(1, $col, 'W il PIT2012');
$worksheet->write('A3', 1.2345);
$worksheet->write('A4', '=SIN(PI()/4)');

•
Scrivere file SWF
use SWF::Builder;
use SWF::Builder::Character::Bitmap; # per inserire immagini
#use SWF::Builder::Character::Text; # per inserire testo
my $mc = SWF::Builder->new (
FrameRate => 1,
BackgroundColor => 'ffffff'
);
my $jpeg = $mc->new_jpeg($catalog_path.'/data/p'.$mycounter.'_big.jpg');
$mc->FrameSize(0,0,$framewidth,$frameheight);
$jpeg->place;
$mc->save($catalog_path.'/data/p'.$mycounter.'.swf');

•
Editare immagini
use GD::Simple;
use Image::Resize;
$img = GD::Simple->new(400,250);
$img->bgcolor('red');
$img->fgcolor('blue');
$img->rectangle(10,10,50,50);
$img->fgcolor('orange');
$img->ellipse(40,40);
print $img->png; # previa open del file contenitore dell'immagine
$img = Image::Resize->new('large.jpg');
print $image->resize(250, 250); # previa open del file contenitore dell'immagine

•
Produrre una GUI (http://www.wxwidgets.org)
use Wx; # interfaccia verso wxwidgets
my $app = Wx::SimpleApp->new(); # il nostro gestore eventi
my $frame = Wx::Frame->new( undef, -1, 'Hello, world!' );
# un pulsante e relativo gestore eventi
my $hello_button=Wx::Button->new($frame,-1,'Ciao NaLUG');
EVT_BUTTON(
$frame,$hello_button, sub {
Wx::MessageBox(”Quanto è bello il PIT”),”Ciao”,wxOK)
}
);

•
Elaborazione in multithreading
use threads;
use threads::shared; # per definire variabili condivise tra i threads my $var :shared:
for (@files_to_encrypt) {
push @thr,threads->new(sub
{
my $krypto=shift;
my $file_to_encrypt=shift;
my $file_encrypted=$file_to_encrypt.".fna";
$krypto->encrypt_file($file_to_encrypt,$file_encrypted);
threads->yield(): # passa ad altro thread appena possibile (decide OS)
},
$krypto,
$_
);
}
for (@thr) {$_->join()}

•
Adesso creiamo un razzo spaziale: server di streaming
use AnyEvent;
use RTSP::Server;
# istanza del server
my $srv = new RTSP::Server(
max_clients => 100,
client_listen_port => 554,
source_listen_port => 5545,
rtp_start_port => 20000,
client_listen_address => '0.0.0.0',
source_listen_address => '0.0.0.0'
);
# inizia ascolto
$srv->listen;
e a questo punto il gestore per i vari eventi...
my $cv = AnyEvent->condvar;
# ...
# ...
# ...
$cv->recv;

• Modern::Perl
use Modern::Perl;

• Modern::Perl
use Modern::Perl;
• è sempre Perl e non un altro linguaggio

• Modern::Perl
use Modern::Perl;
• è un modo di programmare usando le funzioni fornite dalle ultime versioni

• Modern::Perl
use Modern::Perl;
• è un modulo (che attiva le nuove features e sempre strict e warnings)

• Modern::Perl
use Modern::Perl;
• è un modulo (che attiva le nuove features e sempre strict e warnings)
L'introduzione a Modern::Perl dovrete farla voi
inserendolo nei vostri script ed iniziando a programmare

• Modern::Perl
Altro?
Ci sono le API per programmare in Perl su Android

• Modern::Perl
Altro?
Ci sono le API per programmare in Perl su Android
use Android;
my $d = Android->new;
for (1..10) {
my $loc = $d->getLastKnownLocation;
print "Long: $loc->{result}{longitude} Lat: $loc->{result}{latitude}n";
sleep 1
}
Mostrerà le nostre coordinate durante una passeggiata!!!

• Modern::Perl
Altro? Ci sono le API per programmare applicazioni su Facebook
use Modern::Perl;
use CGI::Simple;
use WWW::Facebook::API;
my $q = CGI::Simple->new();
my $fb = WWW::Facebook::API->new(
desktop => 0,
api_key => 'your_api_key',
secret => 'your_secret_key',
query => $q,
);
my $friends_info = $fb->users->get_info(
uids => $user_friends,
fields => [qw/ name /],
);

• Modern::Perl
Altro? Ci sono le API per programmare applicazioni su Facebook
use Modern::Perl;
use CGI::Simple;
use WWW::Facebook::API;
my $q = CGI::Simple->new();
my $fb = WWW::Facebook::API->new(
desktop => 0,
api_key => 'your_api_key',
secret => 'your_secret_key',
query => $q,
);
my $friends_info = $fb->users->get_info(
uids => $user_friends,
fields => [qw/ name /],
);
http://www.facebook.com/developers/
Qui troverete le API keys ed altri dati.

128
Il punto di riferimento di Perl in Italia
Associazione Perl.it
Il linguaggio di programmazione Perl
www.perl.it
www.perl.it/associazione
www.perl.org
Link utili
Distribuzioni e IDE
Strawberryperl, Perl per MS Windows
ActivePerl
Padre, Perl IDE
strawberryperl.com
www.activestate.com/activeperl
padre.perlide.org
Comprehensive Perl Archive Network
Moduli e Classi
metacpan.org
mongers@lists.perl.it
Perlweekly
Irc.freenode.net
Mailing list, IRC
usa Perl responsabilmente
use strict;
use warnings;
IPW, Italian Perl Workshop dal 10 al 12 ottobre 2012 CNR di Bologna.
Scoprite il linguaggio che rende facili le cose facili e possibili quelle difficili
lists.perl.it/sympa/info/mongers
perlweekly.com
#perl.it

• Bibliografia
Documentazione su www.perl.it
Documentazione su www.cpan.org
Modern::Perl by Chromatic
http://www.onyxneon.com/books/modern_perl/index.html (free book)
”Pocket Perl” di Stefano Rodighiero (Larsen), ed. Apogeo
”Corso di Perl” di Stefano Rodighiero su Slideshare
Documentazione sul blog http://szabgab.com
www.cattlegrid.info/blog/2009/11/writing-facebook-applications-in-perl.html
(prima parte di Michele Beltrame)

The End!
Ringrazio il NaLUG,
gli amici della community Perl italiana da cui ho sempre da imparare,
l'Università Federico II di Napoli, Facoltà di Ingegneria
e soprattutto voi che con pazienza e curiosità avete fatto questo piccolo
ed intenso percorso.
Grazie :)

Pit2012 modern perl

Recommended

Recommended

More Related Content

Recently uploaded

Recently uploaded (9)

Featured

Featured (20)

Pit2012 modern perl