Programmazione  »  Guide  »  Guida Perl 

Abbiamo visto che il perl utilizza i normali operatori matematici utilizzati per i numeri: + per l'addizione, - per la sottrazione, * per la moltiplicazione, / per la divisione.
Inoltre, == è utilizzato per l'uguaglianza, e ritorna "vero" o "falso" a seconda che i numeri siano uguali o meno. L'opposto è != .

Come ci si aspetta, < è il simbolo di minore e > quello di maggiore, <= è il simbolo di minore o uguale e => quello di maggiore o uguale.

Utilizzare questi simboli con operatori non matematici, produrrà, se lo script è chiamato con l'opzione -w, un warning.

Ci sono anche operatori che operano a livello di stringa:

.
(si', proprio il punto) esegue la concatenazione

eq
controlla che le stringhe siano uguali

ne
è l'opposto di eq

3 == 3
è vero

3 == "03"
è vero

"bla" eq "arr"
è falso

"bla" ne "arr"
è vero

"bla".3
è equivalente a "bla"."3", che restituisce "bla3"

"bla eek!"
è lo stesso di $bla."eek!"

Ci sono poi gli operatori logici: && (AND), || (OR), ! (NOT). && e || vanno tra due espressioni, mentre ! va all'inizio dell'espressione (poichè la nega)

3 == "03" && "bla"ne "arr"
è vera

Questa espressione funziona perchè == e ne hanno una precedenza più alta rispetto a &&, ma la stessa espressione avrebbe potuto essere scritta più chiaramente come:

(3 == 03) && ("bla" ne "arr") !("eek" eq $bla)
è lo stesso di ("eek" ne $bla)

Una particolarità degli operatori && e || è che possono essere utilizzati come scorciatoie per "se è verificata la condizione fai questo".

unlink "dumbfile" || die "Couldn't remove filen";

In questo modo prima viene valutato unlink() e, se questo ha successo, la condizione introdotta da || viene ignorata, altrimenti (in caso di insuccesso) tale condizione viene eseguita.
L'operatore =~ è particolare: questo guarda che 2 pattern siano uguali e li sostituisce. La sintassi è:

valore =~ /pattern/;
Controlla se le variabili sono uguali
valore !~ /pattern/
Forma corta per !($variabile=~/pattern/;). Controlla che non siano uguali
$variabile =~ s/pattern/replacement/;
Cerca il pattern nella variabile, e la sostituisce con replacement

Se la variabile è omessa, =~ e !~ agiscono su $_
Nella prima forma, senza la s/ , =~ e !~ non modificano gli argomenti, ma testano solo se combaciano. Nella seconda forma, il pattern "replacement" è sostituito a pattern se questo viene trovato.

Ancora, alcuni modificatori possono essere aggiunti prima del ; per specificare come i pattern devono combaciare:

i - case-insensitive
g - match globale. Controlla e restituisce anche più di un valore

I pattern sono espressioni regolari abbastanza simili a quelle di grep. Questo verrà spiegato in seguito.

"bla" =~ /bl/;
vero perchè bla contiene bl
"blabla" =~ /bl/;
idem
"blabla" =~ /bl/g;
trova 2 matches
"bla" !~ /c/i;
vero
$var = "blabla"; $var =~ s/bl/QQ/;
vero, e cambia $var in "QQahbla"
$var =~ s/BL/qq/ig;
vero, e $var diventa "qqahqqah"

L'operatore = assegna il secondo elemento al primo. Ci sono delle scorciatoie per utilizzare questo operatore.

$var += $value:
aggiunge $value a $var
$var -= $value;
sottrae $value da $var
$var *= $value;
moltiplica $var per $value
$var /= $value;
divide $var per $value

Queste espressioni sono invece utilizzate per incrementare il valore delle variabili:

$counter += $step; $var ++
aggiunge 1 a $var
++$var
valuta $var+1

Tutti questi operatori (tranne =~) ed il matching dei pattern si applicano anche in C, in maniera quasi identica.

Altri articoli

Altre guide

Altre newsletter