Operatori condizionali

Perl riconosce tutti i consueti operatori comuni alla maggior parte dei linguaggi di programmazione, quali ad esempio ==, !=, <, >, <= e >=. Anche gli operatori booleani sono gli stessi degli altri linguaggi: &&, || e ! (che possono anche essere scritti come and, or, not).

Una differenza riguarda invece gli operatori di confronto e manipolazione delle stringhe. Come abbiamo già visto Perl non definisce il data-type, quindi l'interprete non ha modo di sapere se una variabile va interpreta come stringa o come numero. Ancora una volta il problema viene aggirato in modo originale: invece di caratterizzare il data-type delle variabili coinvolte, Perl chiede al programmatore di usare l'operatore adeguato al tipo di confronto.

Iniziamo col vedere qualche esempio di confronto tra variabili numeriche

# Confronto tra numeri (con operatori numerici)
my $a = 10 ;
my $b = 2 ;
print "\nConfronto tra numeri (con operatori numerici):\n\n" ;
print '$a == $a = '.($a == $a)."\n" ;
print '$a != $b = '.($a != $b)."\n" ;
print '$a <  $b = '.($a <  $b)."\n" ;
print '$a <= $b = '.($a <= $b)."\n" ;
print '$a >  $b = '.($a >  $b)."\n" ;
print '$a >= $b = '.($a >= $b)."\n" ;

# Confronto tra numeri (con operatori alfanumerici)
$a = 10 ;
$b = 2 ;
print "\nConfronto tra numeri (con operatori alfanumerici):\n\n" ;
print '$a eq $a = '.($a eq $a)."\n" ;
print '$a ne $b = '.($a ne $b)."\n" ;
print '$a lt $b = '.($a lt $b)."\n" ;
print '$a le $b = '.($a le $b)."\n" ;
print '$a gt $b = '.($a gt $b)."\n" ;
print '$a ge $b = '.($a ge $b)."\n" ;

che fornisce come output

Confronto tra numeri (con operatori numerici):

$a == $a = 1
$a != $b = 1
$a <  $b =
$a <= $b =
$a >  $b = 1
$a >= $b = 1

Confronto tra numeri (con operatori alfanumerici):

$a eq $a = 1
$a ne $b = 1
$a lt $b = 1
$a le $b = 1
$a gt $b =
$a ge $b =

Spieghiamo il risultato: quando confrontiamo i valori a = 10 e b = 2 come numeri otteniamo che la variabile a è maggiore di b. Al contrario, quando le confrontiamo come stringhe troviamo il risultato opposto, perché il testo 2 viene dopo (alfabeticamente) rispetto al testo 10 (cioè la stringa "2" è maggiore della stringa "10").

Se le stesse variabili vengono definite come stringhe si trova esattamente il risultato opposto.

# Confronto tra stringhe (con operatori alfanumerici)
my $uno = "10" ;
my $due	= "2" ;
print "\nConfronto tra stringhe (con operatori alfanumerici):\n\n" ;
print '$uno eq $uno = '.($uno eq $uno)."\n" ;
print '$uno ne $due = '.($uno ne $due)."\n" ;
print '$uno lt $due = '.($uno lt $due)."\n" ;
print '$uno le $due = '.($uno le $due)."\n" ;
print '$uno gt $due = '.($uno gt $due)."\n" ;
print '$uno ge $due = '.($uno ge $due)."\n" ;

# Confronto tra stringhe (con operatori numerici)
$uno	= "10" ;
$due	= "2" ;
print "\nConfronto tra stringhe (con operatori numerici):\n\n" ;
print '$uno == $uno = '.($uno == $uno)."\n" ;
print '$uno != $due = '.($uno != $due)."\n" ;
print '$uno <  $due = '.($uno <  $due)."\n" ;
print '$uno <= $due = '.($uno <= $due)."\n" ;
print '$uno >  $due = '.($uno >  $due)."\n" ;
print '$uno >= $due = '.($uno >= $due)."\n" ;

che produce

Confronto tra stringhe (con operatori alfanumerici):

$uno eq $uno = 1
$uno ne $due = 1
$uno lt $due = 1
$uno le $due = 1
$uno gt $due =
$uno ge $due =

Confronto tra stringhe (con operatori numerici):

$uno == $uno = 1
$uno != $due = 1
$uno <  $due =
$uno <= $due =
$uno >  $due = 1
$uno >= $due = 1

In questo caso il testo 10 è minore (come stringa) del testo 2 (per una questione di ordine alfabetico, esattamente come visto sopra). Il testo 10 è invece maggiore del testo 2 quando operiamo un confronto numerico, perché in questo caso Perl confronta la lunghezza delle due stringhe, esattamente come abbiamo visto nella lezione precedente. Nel secondo caso infatti Perl "da per scontato" che il confronto $uno > $due riguardi la lunghezza delle stringhe coinvolte, per cui la stringa 10 (di lunghezza 2) risulta maggiore della stringa 2 (di lunghezza 1).