# Perl/Variabili scalari

Perl
Copertina Bibliografia Tutti i moduli · Sviluppo
    CopertinaPerl/Copertina
* IntroduzionePerl/Introduzione
* C'è Perl?Perl/C'è Perl?
* Primo programma: Ciao Mondo!Perl/Primo programma: Ciao Mondo!
** Primo programma in un filePerl/Primo programma in un file
* VariabiliPerl/Variabili
** Variabili scalariPerl/Variabili scalari
** Variabili vettoriPerl/Variabili vettori
** Variabili hashPerl/Variabili hash
* IstruzioniPerl/Istruzioni
** Istruzioni minimePerl/Istruzioni minime
** Istruzioni compostePerl/Istruzioni composte
** Istruzioni racchiuse o bloccoPerl/Istruzioni racchiuse o blocco
** Istruzioni etichettaPerl/Istruzioni etichetta
** Istruzioni particolari su blocchi o etichettePerl/Istruzioni particolari su blocchi o etichette
** Istruzioni decisionaliPerl/Istruzioni decisionali
** CicliPerl/Cicli
* Applicare la teoriaPerl/Applicare la teoria
* FunzioniPerl/Funzioni
* Funzioni Native sulle variabiliPerl/Funzioni Native sulle variabili
** Funzioni Native su scalariPerl/Funzioni Native su scalari
** Funzioni Native su vettoriPerl/Funzioni Native su vettori
** Funzioni Native su hashPerl/Funzioni Native su hash
* FilePerl/File
* Espressioni regolariPerl/Espressioni regolari
** Espressioni regolari (oltre)Perl/Espressioni regolari (oltre)
** Espressioni regolari (contesto)Perl/Espressioni regolari (contesto)
Modifica il sommario
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.
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:
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:
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:
NOTA se p e s fossero in virgola mobile il loro valore viene incrementato/decrementato di uno senza alterare la parte decimale. es

### 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:

#### 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 .
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:
senza problemi. Come nel caso precedente se dovessimo scrivere il carattere ->"<- come carattere all'interno della stringa, occorrerà farlo precedere dal carattere ->\<- :
Vediamo ora le caratteristiche di usare il simbolo ->"<- al posto di ->'<-
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)?
E se all'interno di una stringa delimitata da ->"<- ci fosse il carattere "?
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:
quindi il successivo esempio occorre scriverlo:
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
Se si volesse scrivere la frase : PIPPO corre nel prato (indipendentemente da cosa c'è in $b)
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 :
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:

#### Operazioni con le stringhe
##### Concatenare più stringhe

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

##### istruzione "complessa" con le stringhe

ma forse è meglio scriverla:
oppure anche:

### 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:
Vuol dire che associamo "all'etichetta" $a il contenuto 5 ed usiamo poi l'etichetta nel programma al posto del valore:
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 $ :
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 :
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:

### 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:
che produrrà:
Esempio con le stringhe:
che produrrà:
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:

### Conversione implicita a stringa
## 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
viene "espansa" nella sua equivalente:
e così tutte le altre:
Vediamo ora degli esempi con dei valori:
E con le stringhe ? Un esempio è meglio delle parole:

# Riassunto

Le variabili scalari:
* sono identificate dal sigillo "$" davanti al nome
* contengono un solo valore
* si adattano al contesto nel quale sono usate