Copertina

Bibliografia
Tutti i moduli · Sviluppo

Copertina Perl/Copertina

Le variabili scalari sono i mattoni delle variabili in Perl. Rappresentano una "entità" singola : una sola informazione.

Non è necessario dichiarare una variabile per usarla.

Per distinguere le variabili scalari da altri elementi si deve mettere davanti al nome della variabile il carattere "$". il carattere "$" viene chiamato "sigillo" e serve quindi a identificare le variabili scalari (un solo valore).

Dato che il Perl è un linguaggio che si adatta al "contesto", il contenuto di una variabile sarà adattato automaticamente all'uso che ci si aspetta. Per esempio : il valore 5 di una variabile verrà interpretato come 5 numerico in caso di somma o di "5" in caso di uso come stringa senza dover convertire esplicitamente.

Entriamo ora nei dettagli:

Il nome

Per identificare una variabile scalare (un valore) occorre anteporre al nome il carattere $. Il nome di una variabile DEVE iniziare con "lettere", "_" , "'", mentre dal secondo carattere oltre ai precedenti si possono usare i "numeri" fino ad un massimo di 256 caratteri.

NOTA: le variabili $1, $2 etc sono utilizzate "internamente" dal linguaggio, pertanto potrebbe essere impossibile per l'interprete distinguere la variabile dichiarata da quella interna.Per questo motivo non è possibile usare i numeri come primo carattere di una variabile.

Inoltre essendo un linguaggio "case sensitive" le lettere maiuscole e le lettere minuscole sono differenti.

 $a; # è la variabile a
 $A; # è la variabile A diversa da a

NOTA: il nome di una variabile non può iniziare con numeri!

Come precedentemente detto , l'interprete Perl mette nel contesto la variabile scalare e la "usa" nel modo migliore.

L'informazione può essere :

un numero (positivo o negativo) intero (es 23 , un milione 1000000 o 1_000_000, -12)
un numero (positivo o negativo) in virgola mobile (es 7.20 , 7.20e3 )
un numero intero ottale (es 02567, Best Practice usare oct('02567') )
un numero intero esadecimale (es 0xf8d7, Best Practice usare oct('0xf8d7'))
un numero intero binario (es 0b101, Best Practice usare oct('0b101'))
una stringa (successione di caratteri es."abcd")
la locazione di un'altra variabile (o altra entità) (reference)
il valore indefinito "undef"

I numeri

I numeri in Perl sono in forma "letterale" maggiormente comprensibili dall'uomo. È possibile utilizzare in più forme per esprimere i numeri.

Vediamo alcuni esempi:

 
 $primo_numero = 5;        # decimale 
 
 $primo_numero = 05;       # ottale (cifre da '''0''' a '''7''') 
 
 $primo_numero = 5.0;      # decimale in virgola mobile 
 
 $primo_numero = 5.0e0;    # decimale in virgola mobile (NOTA : '''e''' sta per 10 alla ...)
 
 $primo_numero = 0x5;      # esadecimale (cifre da '''0''' a '''9''' e lettere da '''a''' a '''f''' )

sono tutti modi di far valere la variabile primo_numero il numero intero 5.

NOTA per i numeri in migliaia c'è la possibilità di separare il valore con "_" senza che questo crei complicazioni di interpretazione.quindi scrivere 1000 o 1_000 è la stessa cosa (ma è più leggibile).

NOTA TECNICA indipendentemente dal valore i numeri internamente al linguaggio sono tutti trattati come double-precision floating-point.

Operazioni con i numeri

In Perl sono possibili le operazioni di assegnamento (=) , somma (+), sottrazione (-), moltiplicazione (*), divisione (/), modulo (%), elevamento a potenza (**), incremento (prima e dopo) (++), decremento (prima e dopo) (--). Questo è possibile tramite dei simboli che vengono chiamati operatori. Vediamo insieme alcune operazioni:

 $p = 7;        # assegnamento
 $s = 9; 
 $r = 0;

 $r = $p + $s;  # somma      r vale ora 16 
 $r = $p - $s;  # differenza r vale ora -2 
 $r = $p * $s;  # moltiplicazione r vale ora 63
 $r = $p / $s;  # divisione       r vale ora 0.777777777777778
 $r = $p % $s;  # modulo     r vale ora 7
 $r = $p ** $s; # elevamento r vale ora 40353607 ( 7 elevato alla 9 )

NOTA per operazioni più complesse ci sono delle apposite funzioni

NOTA 1 il simbolo modulo ed il simbolo hash sono lo stesso "%" ma cambia il contesto.

Vediamo ora gli operatori di incremento e decremento. Questi aumentano o diminuiscono di una unità lo scalare numerico. Questa modifica della variabile può essere fatta prima o dopo l'uso della variabile stessa:

Se l'operatore viene messo prima della variabile, allora questa viene prima modificata e poi letta all'interno del codice.
Al contrario se l'operatore viene messo dopo la variabile, allora, questa, viene prima letta e poi modificata.

vediamo un esempio:

 $p = 7;        # assegnamento
 $q = 0; 
 $s = 9; 
 $r = 0;

 $r = $s++;     # post incremento ora $r = 9  , $s = 10
 $q = ++$s;     # pre  incremento ora $q = 11 , $s = 11 

 $r = $p--;     # post decremento ora $r = 7  , $p = 6
 $q = --$p;     # pre  decremento ora $q = 5  , $p = 5

NOTA se p e s fossero in virgola mobile il loro valore viene incrementato/decrementato di uno senza alterare la parte decimale. es

$a = 1.2; $a++; # ora  $a vale 2.2

La stringa

La stringa è una fila di caratteri che può essere anche vuota. Quindi una fila di caratteri (qualsiasi) è una stringa.

La stringa "pura"

Con questa definizione intendo una sequenza di caratteri che vengono assegnati o usati "così come sono". Il carattere che distingue una stringa "pura" dal contesto di programmazione è il ->'<-.

ESEMPI:

 # ESEMPIO 1
 $a = '1234';          # in $a c'è una stringa di quattro caratteri (1234).
 $a = 'abcd';          # in $a c'è una stringa di quattro caratteri (abcd).
 $a = 'abcd ';         # in $a c'è una stringa di cinque caratteri  (abcd e uno spazio).
 $a = 'questa è una stringa di caratteri';         # in $a c'è una stringa di 33 caratteri .
 $a = ''               # in $a c'è una stringa vuota !

La stringa "interpolata"

La stringa interpolata consente la sostituzione di alcune entità indicate nella stringa con il loro valore. In pratica consente di scrivere il valore di una variabile. Il carattere che distingue una stringa "interpolata" dal contesto di programmazione è il ->"<-. Vediamo gli esempi precedenti con le "" al posto di .

 # ESEMPIO 1
 $a = "1234";          # in $a c'è una stringa di quattro caratteri (1234) uguale all'esempio precedente.
 $a = "abcd";          # in $a c'è una stringa di quattro caratteri (abcd) uguale all'esempio precedente.
 $a = "abcd ";         # in $a c'è una stringa di cinque caratteri  (abcd e uno spazio) uguale all'esempio precedente.
 $a = "questa è una stringa di caratteri";         # in $a c'è una stringa di 33 caratteri .
 $a = ""               # in $a c'è una stringa vuota !

Per il gruppo di stringhe dell'esempio 1 scriverle con "" o con '' è esattamente la stessa cosa : il valore finale sarà lo stesso. Ovviamente essendo il carattere ->"<- il carattere che indica inizio e la fine non si ha problemi con il carattere ->'<- quindi è possibi scrivere:

 $a = "questa e' una stringa di caratteri";

senza problemi. Come nel caso precedente se dovessimo scrivere il carattere ->"<- come carattere all'interno della stringa, occorrerà farlo precedere dal carattere ->\<- :

 $a = "\"virgolettato\""; # a ora ha il valore "virgolettato"

Vediamo ora le caratteristiche di usare il simbolo ->"<- al posto di ->'<-

 #ESEMPIO 2
 $a = "quest'estate farà caldo"; # in $a c'è una stringa 22 caratteri (quest'estate farà caldo).
 $b = "$a";      # in $b c'è una stringa 22 caratteri (quest'estate farà caldo) dato dalla sostituzione del valore di $a.
 $a = "$a";      # in $a c'è il valore di $a cioè lo stesso valore di prima !.

Quindi con il delimitatore ->"<- è possibile usare il valore delle variabili al posto del nome della variabile stessa.

I caratteri speciali

Si è detto che il carattere ->'<- può individuare l'inizio e la fine di una stringa. Si è detto che anche il carattere ->"<- può individuare l'inizio e la fine di una stringa.

Ma se all'interno di una stringa delimitata da ->'<- ci fosse il carattere ', come si potrebbe scrivere il seguente codice (errato)?

 $a = 'questa e' una stringa';         # stringa di 21 caratteri ERRATA SINTASSI.

E se all'interno di una stringa delimitata da ->"<- ci fosse il carattere "?

 $a = "questa e' una "stringa"";         # stringa di 23 caratteri ERRATA SINTASSI.

Per evitare limitazioni e poter scrivere il carattere ->'<- all'interno di una stringa "pura" occorre anticiparlo dal carattere ->\<- che fa in modo di dire all'interprete che il carattere che segue (in questo caso il ') è da considerarsi in modo particolare. Vediamo ora come si deve scrivere la riga precedente:

 $a = 'questa e\' una stringa';         # in $a c'è una stringa di 21 caratteri GIUSTA SINTASSI.

quindi il successivo esempio occorre scriverlo:

 $a = "questa e' una \"stringa\"";      # stringa di 23 caratteri GIUSTA SINTASSI.

I caratteri speciali sono delle combinazioni di caratteri semplici che "servono a informare" che si vuole fare una "azione" particolare. Da prestare attenzione che:

nel caso della stringa pura il solo carattere speciale è il \'

Le stringhe possono contenere caratteri speciali , alcuni di questi sono:

\n	newline (torna a capo)
\r	return
\t	tab
\f	formfeed
\b	backspace
\a	bell (il beep del computer)
\e	Escape
\007	Numero espresso in Ottale della tabella ascii (equivalente a \a beep)
\x07	Numero espresso in Esadecimale della tabella ascii (equivalente a \a beep)
\cM	il carattere di controllo CTRL+M
\\	backslash
\"	doppio apice
\$	il carattere $ (altrimenti potrebbe essere una variabile!)
\l	prossima lettera minuscola
\u	prossima lettera maiuscola
\L	tutti i caratteri che seguono in minuscolo fino a \E
\U	tutti i caratteri che seguono in maiuscolo fino a \E
\Q	quota tutti i caratteri non alfanumerici fino a \E
\E	fa terminare l'azione di \L,\U,\Q

Vediamo qualche esempio: Se si volesse scrivere la frase : "pippo" corre nel prato

 $b = 'pippo';
 $c = 'corre nel prato';
 $d = '"'.$b.'"'." ".$c." contento";  # contiene : "pippo" corre nel prato contento 
 $d = " \"$b\" $c contento";          # contiene : "pippo" corre nel prato contento 
                                      #            (un po' meglio)

Se si volesse scrivere la frase : PIPPO corre nel prato (indipendentemente da cosa c'è in $b)

 $d = " \U$b\E $c contento";          # verrà mostrato come : PIPPO corre nel prato contento

ATTENZIONE i simboli ' e " sono operatori ( e non solo convenzioni di sintassi !)

l'uso di q/.../ e qq/.../

Per una migliore comprensione del testo sono stati introdotti al posto di ' e " , rispettivamente q/.../ per ' e qq/.../ per " quindi avremmo potuto scrivere anche :

 $a = q//;                     # stringa vuota
 $a = qq//;                    # stringa vuota
 $b = q/pippo/;                # stringa 
 $c = q/corre nel prato/;      # altra stringa 
 $d = qq/$b $c contento/;      # contiene : pippo corre nel prato contento
 $e = q/$b $c contento/;       # contiene : $b $c contento

Inoltre è possibile sostituire al carattere / con i caratteri {,(,% per migliorare la leggibilità : per esempio se dovessi scrivere 2006/12/22 con qq/ dovrei distinguere fra / usato come simbolo di separazione della data e / usato come termine di qq/. Per fare questo è possibile cambiare simbolo (oppure usare il carattere speciale \/ vedi dopo). Quindi potremmo scrivere:

 
 $f = "2006/12/22";
 $f = qq(2006/12/22);
 $f = qq{2006/12/22};

Operazioni con le stringhe

Concatenare più stringhe

Con il carattere . è possibile concatenare più stringhe per esempio:

 $d = $b . " " . $c . " contento";  # contiene : "pippo corre nel prato contento"

istruzione "complessa" con le stringhe

 $d = q/$b=/ . qq/$b/ . "\n";  # contiene "$b=pippo" e un ritorno a capo

ma forse è meglio scriverla:

 $d = '$b=' . "$b\n";  # contiene "$b=pippo" e un ritorno a capo

oppure anche:

 $d = '$b=' . $b. "\n";  # contiene "$b=pippo" e un ritorno a capo

I reference (piccola introduzione)

Questa sezione introduce l'argomento per avere un quadro generale. Si veda la sezione dedicata per approfondire l'argomento.

Esaminiamo la scrittura sintattica:

$a = 5;

Vuol dire che associamo "all'etichetta" $a il contenuto 5 ed usiamo poi l'etichetta nel programma al posto del valore:

print $a."\n";

Il reference associa all'etichetta una sua etichetta pertanto lo stesso contenuto può essere scritto utilizzando "l'etichetta" $a o in modo adatto il suo reference.

Un modo per creare un reference è quello di anteporre alla variabile il simbolo \.
Un modo per riottenere il valore originale è quello di anteporre $ :

 $a = 5;             # variabile a
 $ref_a = \$a;       # Ora sia ref_a che a "associano" lo stesso contenuto 5
 print $a."\n";      # si ottiene 5
 print $$ref_a."\n"; # si ottiene 5
 $a++;               # ora a = 6 e quindi anche ref_a
 print $a."\n";      # si ottiene 6
 print $$ref_a."\n"; # si ottiene 6
 $$ref_a++;          # ora ref_a = 7 ed anche a perché è lo stesso valore ad essere trattato!
 print $a."\n";      # si ottiene 7
 print $$ref_a."\n"; # si ottiene 7

NOTA: nell'esempio si è associato ad uno scalare $ref_a un altro scalare $a.è possibile associare qualsiasi tipo di variabile !

Il valore indefinito undef

Il valore undef è uno speciale valore per dire che la variabile non è stata ancora associata ad alcun valore. Per esempio se si dichiara una variabile :

$u;

ma non si associa alcun valore questa assume lo speciale valore undef. Undef è un valore "polimorfico" nel senso che viene associato a 0 con i numeri e a stringa nulla con le stringhe.

È possibile assegnare ad una variabile il valore undef:

$u = undef;

Dove sono i booleani?

Nel Perl non esistono dei tipi booleani appositi e si usa questa convenzione:

viene considerato false tutto quello che è associabile a 0 , "" (stringa vuota) e "0"
viene considerato true tutto quello che non è false

Uso di Or o || e di And o &&

Queste parole chiave si utilizzano per controllare la logica e per "operare" sugli scalari.

Or risulta "vero" se uno dei due estremi risulta "vero" in particolare viene valutato prima l'elemento a sinistra e poi quello a destra. And risulta "falso" se uno dei due estremi è "falso" in particolare viene valutato prima l'elemento a sinistra e poi quello a destra. Quindi Or "cerca" un "vero" per tornare "vero" mentre And cerca un "falso" per tornare "falso".

Vediamo il codice:

 $a = 0;
 $b = 1;
 print "or:".( $a or $b )."\n";
 print "and:"( $a and $b )."\n";

che produrrà:

or:1 
and:0

Esempio con le stringhe:

 $a = "";
 $b = "vero";
 print "or:".( $a or $b )."\n";
 print "and:"( $a and $b )."\n";

che produrrà:

or:vero 
and:

NOTA: Esistono altri operatori logici ( ma non verranno trattati ... da fare )

Dopo tanta teoria un po' di pratica ...

Vediamo ora alcuni assegnamenti e cerchiamo di capirne il risultato (prima di vedere la soluzione!).

Date le tre variabili:

 $a = 10;      # numero  10
 $b = '10';    # stringa 10 
 $c = 'dieci'; # stringa dieci
 $d = "$c";    # stringa dieci come $c
 $e;           # undef
  
 print "a:$a , b:$b , c:$c , d:$d\n"; # scrive a:10 , b:10 , c:dieci , d:dieci

Conversione implicita a numeri

 print '( $a + $b )='.( $a + $b )."\n"; # scrive ( $a + $b )=20 $b è stato convertito in 10 numerico
  
 print '( $b + $c )='.( $b + $c )."\n"; # scrive ( $b + $c )=10 $c è stato convertito in 0 numerico
  
 print '( $c + $d )='.( $c + $d )."\n"; # scrive ( $c + $d )=0  $c e $d sono stati convertiti in 0 numerico
  
 print '( $d + $e )='.( $d + $e )."\n"; # scrive ( $d + $e )=0  $d ed $e sono stati convertiti in 0 numerico

Conversione implicita a stringa

 print " $a ha il valore $a\n";       # scrive 10 ha il valore 10 è stato interpretato $a
 print ' $a ha il valore $a'."\n";    # scrive $a ha il valore $a NON è stato interpretato $a
  
 print " \$a ha il valore $a\n";      # scrive $a ha il valore 10 vedi \$ che cambia interpretazione di $a
  
 print ' $a ha il valore '.$a."\n";   # scrive $a ha il valore 10 $a è ora in ''
  
 print ' $e ha il valore '.$e."\n";   # scrive $e ha il valore    infatti undef viene tradotto come ""

Assegnamento oltre "="

Abbiamo visto che per assegnare un valore ad una variabile scalare è possibile usare il segno di uguale. Questo però non è l'unico modo con il quale è possibile assegnare dei valori ad una variabile. Infatti esistono delle forme contratte che "semplificano" la stesura del codice lasciandolo più pulito:

+=	somma numerica
-=	sottrazione numerica
*=	moltiplicazione numerica
/=	divisione numerica
%=	modulo numerico
**=	elevamento a potenza
.=	congiunzione di stringa
x=	ripetizione di stringa

Queste espressioni non fanno altro che fare l'operazione espressa dai caratteri prima dell "=" (es + somma, - sottrazione, . concatemento, * moltiplicazione etc) sulla variabile stessa con il dato di destra. Vediamo un esempio che chiarisce molto: L'espressione

 $a += $b;

viene "espansa" nella sua equivalente:

 $a = $a + $b;

e così tutte le altre:

 $a -= $b;          $a = $a - $b;
 $a *= $b;          $a = $a * $b;
 $a /= $b;          $a = $a / $b;
 $a %= $b;          $a = $a % $b;
 $a **= $b;         $a = $a ** $b;
 $a .= $b;          $a = $a . $b;
 $a x= $b;          $a = $a x $b;

Vediamo ora degli esempi con dei valori:

 $a = 32;
 $b = 5;
  
 $a += $b;  # ora $a è uguale a 37    ( 32 + 5 )
 $a -= $b;  # ora $a è uguale a 32    ( 37 - 5 )
 $a *= $b;  # ora $a è uguale a 160   ( 32 * 5 )
 $a /= $b;  # ora $a è uguale a 32    ( 160 / 5 )
 $a %= $b;  # ora $a è uguale a 2     ( resto di 32 / 5) 
 $a **= $b; # ora $a è uguale a 64    ( 2 alla quinta )
 $a .= $b;  # ora $a è uguale a '645' ( '64' . '5' )
 $a x= $b;  # ora $a è uguale a '645645645645645' ( '645' cinque volte )

E con le stringhe ? Un esempio è meglio delle parole:

 $a = "ciao"; # nota in numero 0
 $b = 5;
  
 $a += $b;  # ora $a è uguale a 5    ( 0 + 5 )
 $a -= $b;  # ora $a è uguale a 0    ( 5 - 5 )
 $a *= $b;  # ora $a è uguale a 0    ( 0 * 5 )
 $a /= $b;  # ora $a è uguale a 0    ( 0 / 5 )
 $a %= $b;  # ora $a è uguale a 0    (resto di 0 / 5) 
 $a **= $b; # ora $a è uguale a 0    ( 0 alla quinta )
 $a .= $b;  # ora $a è uguale a '05' ( '0' . '5' )
 $a x= $b;  # ora $a è uguale a '0505050505' ( '05' cinque volte )

Riassunto

Le variabili scalari:

sono identificate dal sigillo "$" davanti al nome
contengono un solo valore
si adattano al contesto nel quale sono usate

Perl/Variabili scalari

Indice