Le variabili rappresentano un elemento fondamentale nella programmazione di script e nella comprensione del funzionamento del codice che si copia e incolla dal web nel tuo sistema Linux. Approfondiamo questo argomento per iniziare con il piede giusto!
Introduzione alle Variabili
Le variabili sono identificatori testuali utilizzati per rappresentare valori, siano essi stringhe di testo o numeri. Quando queste variabili vengono impiegate all’interno di comandi o espressioni, il sistema le interpreta sostituendole con il valore che effettivamente contengono.
Per creare una variabile, basta assegnarle un nome e un valore corrispondente. È cruciale che i nomi delle variabili siano descrittivi, facilitando la memorizzazione del loro contenuto. I nomi non devono iniziare con un numero o includere spazi, anche se è consentito l’uso del carattere di sottolineatura all’inizio. Per il resto, si può utilizzare qualsiasi combinazione di caratteri alfanumerici, sia maiuscoli che minuscoli.
Esempi Pratici
Di seguito, creeremo cinque variabili come esempio. La sintassi richiede il nome della variabile, il simbolo di uguale (=) e il valore associato. È importante notare l’assenza di spazi prima o dopo il simbolo di uguale. L’azione di associare un valore a una variabile è nota come assegnazione.
Nello specifico, creeremo quattro variabili di tipo stringa e una variabile numerica, denominata this_year:
persona=Luca
sistema_preferito=Unix
amico=Marco
alimento_preferito=Pizza
anno_corrente=2024
Per visualizzare il valore memorizzato in una variabile, si utilizza il comando echo
. È necessario premettere il nome della variabile con il simbolo del dollaro ($) ogni volta che si vuole fare riferimento al suo valore, come illustrato qui sotto:
echo $persona
echo $sistema_preferito
echo $anno_corrente
Utilizziamo ora tutte le nostre variabili contemporaneamente:
echo "$sistema_preferito è per $persona come $alimento_preferito è per $amico (c) $anno_corrente"
I valori delle variabili sostituiscono i loro nomi. È possibile modificare i valori delle variabili in qualsiasi momento. Per assegnare un nuovo valore, ad esempio alla variabile sistema_preferito
, ripeti la stessa operazione fatta durante l’assegnazione iniziale, come mostrato di seguito:
sistema_preferito=Ubuntu
Rieseguendo il comando di visualizzazione delle variabili, otterremo un risultato diverso:
echo "$sistema_preferito è per $persona come $alimento_preferito è per $amico (c) $anno_corrente"
Quindi, è possibile riutilizzare lo stesso comando che fa riferimento alle stesse variabili, ottenendo risultati diversi in base alle modifiche apportate ai valori memorizzati nelle variabili.
Più avanti approfondiremo l’uso delle virgolette con le variabili. Nel frattempo, ecco alcuni punti chiave da tenere a mente:
- Una variabile racchiusa tra virgolette singole è interpretata come una stringa letterale e non come variabile.
- Le variabili racchiuse tra virgolette doppie vengono elaborate come variabili.
- Per visualizzare il valore di una variabile, è necessario usare il simbolo $.
- Una variabile senza il simbolo $ restituisce il suo nome, e non il valore.
È anche possibile creare una variabile il cui valore deriva da una o più altre variabili. Il comando seguente crea una variabile denominata prodotto_dell_anno
e le assegna i valori combinati delle variabili sistema_preferito
e anno_corrente
:
prodotto_dell_anno="$sistema_preferito $anno_corrente"
echo $prodotto_dell_anno
Utilizzo delle Variabili negli Script
Gli script perderebbero gran parte della loro utilità senza l’uso di variabili. Le variabili conferiscono quella flessibilità che rende uno script una soluzione generica, anziché un’azione specifica. Per illustrare questa differenza, esaminiamo uno script che conta i file nella directory /dev
.
Incolla questo codice in un editor di testo e salvalo come conta_file.sh
:
#!/bin/bash directory_da_contare=/dev conteggio_file=$(ls $directory_da_contare | wc -l) echo $conteggio_file file in $directory_da_contare
Prima di eseguire lo script, rendilo eseguibile con il comando seguente:
chmod +x conta_file.sh
Per eseguire lo script, digita il comando seguente:
./conta_file.sh
Lo script visualizzerà il numero di file presenti nella directory /dev
. Ecco come funziona:
- Viene definita una variabile chiamata
directory_da_contare
e le viene assegnata la stringa/dev
. - Viene definita una seconda variabile chiamata
conteggio_file
. Questa variabile ottiene il suo valore da una sostituzione di comando, ovvero l’espressione tra parentesi$()
. Si noti la presenza del simbolo$
prima della parentesi. Questa sintassi valuta i comandi all’interno delle parentesi e ne restituisce il valore finale, che viene assegnato aconteggio_file
. La variabileconteggio_file
accetta un valore da memorizzare, senza curarsi di come questo valore sia stato ottenuto. - Il comando valutato nella sostituzione del comando esegue un listato
ls
della directory presente nella variabiledirectory_da_contare
, che è stata impostata su/dev
. Quindi, lo script esegue in pratica il comandols /dev
. - L’output di questo comando viene reindirizzato al comando
wc
. L’opzione-l
(conteggio delle righe) fa sì chewc
conti il numero di righe nell’output del comandols
. Dato che ogni file è elencato su una riga separata, questo corrisponde al numero di file e sottodirectory presenti in/dev
. Questo valore viene assegnato alla variabileconteggio_file
. - L’ultima riga dello script usa il comando
echo
per visualizzare il risultato.
Questo script funziona però solo per la directory /dev
. Come possiamo modificarlo per farlo funzionare con qualsiasi directory? È sufficiente una piccola modifica.
Parametri da Riga di Comando negli Script
Molti comandi, come ls
e wc
, accettano parametri da riga di comando che ne specificano il comportamento. Se ad esempio si vuole che ls
operi sulla home directory e visualizzi anche i file nascosti, si può usare il seguente comando, dove il simbolo ~
e l’opzione -a
sono parametri:
ls ~ -a
Anche gli script possono accettare parametri dalla riga di comando, che vengono identificati come $1
per il primo, $2
per il secondo e così via, fino a $9
per il nono. In realtà esiste anche $0
, ma è riservato a contenere il nome dello script.
È possibile fare riferimento ai parametri della riga di comando in uno script nello stesso modo in cui si fa con le variabili ordinarie. Modifichiamo lo script precedente come segue, salvandolo con il nuovo nome conta_file2.sh
:
#!/bin/bash directory_da_contare=$1 conteggio_file=$(ls $directory_da_contare | wc -l) echo $conteggio_file file in $directory_da_contare
Questa volta, alla variabile directory_da_contare
viene assegnato il valore del primo parametro della riga di comando, $1
.
Il resto dello script funziona esattamente come prima. Ora, lo script è diventato una soluzione generica, in grado di operare su qualsiasi directory, e non solo su /dev
.
Per rendere eseguibile questo nuovo script, usa questo comando:
chmod +x conta_file2.sh
Proviamo ora con diverse directory. Iniziamo con /dev
per verificare che il risultato sia coerente con quello precedente. Digita i seguenti comandi:
./conta_file2.sh /dev
./conta_file2.sh /etc
./conta_file2.sh /bin
Si ottiene lo stesso risultato (207 file) di prima per /dev
. Questo è positivo, e i risultati per le altre directory sono quelli attesi.
Per abbreviare ulteriormente lo script, è possibile fare a meno della variabile directory_da_contare
e fare riferimento direttamente a $1
, come mostrato qui sotto:
#!/bin/bash conteggio_file=$(ls $1 | wc -l) echo $conteggio_file file in $1
Variabili Speciali
Abbiamo già accennato a $0
, che contiene sempre il nome del file dello script. Ciò permette ad esempio di visualizzare il nome corretto dello script anche se è stato rinominato. Questo è particolarmente utile nelle situazioni di logging, dove è fondamentale conoscere il nome del processo che ha generato una certa voce.
Le seguenti sono altre variabili predefinite speciali:
$#
: Il numero di parametri passati allo script dalla riga di comando.$@
: Tutti i parametri passati allo script dalla riga di comando.$?
: Lo stato di uscita dell’ultimo processo eseguito.$$
: L’identificatore del processo (PID) dello script in esecuzione.$USER
: Il nome utente dell’utente che esegue lo script.$HOSTNAME
: Il nome host del computer su cui lo script è in esecuzione.$SECONDS
: Il numero di secondi trascorsi dall’inizio dell’esecuzione dello script.$RANDOM
: Restituisce un numero casuale.$LINENO
: Restituisce il numero di riga corrente dello script.
Vediamole tutte in azione. Salva il seguente codice come file di testo chiamato special.sh
:
#!/bin/bash echo "Sono stati passati $# parametri da riga di comando" echo "Essi sono: $@" echo "Il primo parametro è: $1" echo "Lo script si chiama: $0" pwd echo "Il comando pwd ha restituito $?" echo "Questo script ha PID $$" echo "Lo script è stato avviato da $USER" echo "È in esecuzione su $HOSTNAME" sleep 3 echo "È in esecuzione da $SECONDS secondi" echo "Numero casuale: $RANDOM" echo "Questa è la riga numero $LINENO dello script"
Rendilo eseguibile con il seguente comando:
chmod +x special.sh
Esegui ora lo script con diversi parametri:
Variabili d’Ambiente
Bash si serve delle variabili d’ambiente per definire e memorizzare le proprietà dell’ambiente in cui si avvia. Queste informazioni, come nome utente, impostazioni locali, numero di comandi che la cronologia può salvare, editor predefinito, ecc. sono facilmente accessibili a Bash.
Per visualizzare le variabili d’ambiente attive nella sessione Bash, usa il comando seguente:
env | less
Scorrendo l’elenco, si possono individuare alcune variabili che potrebbero essere utili all’interno degli script.
Esportare le Variabili
Quando uno script viene eseguito, opera in un processo separato, e le variabili che utilizza non sono visibili al di fuori di quel processo. Per condividere una variabile con un altro script invocato dal primo, è necessario esportarla. Mostriamo come fare con due script d’esempio.
Salva il seguente codice in un file chiamato script_uno.sh
:
#!/bin/bash prima_var=alfa seconda_var=beta echo "$0: prima_var=$prima_var, seconda_var=$seconda_var" export prima_var export seconda_var ./script_due.sh echo "$0: prima_var=$prima_var, seconda_var=$seconda_var"
Questo script crea due variabili, prima_var
e seconda_var
, assegnando loro dei valori. Le visualizza nel terminale, poi le esporta e infine invoca script_due.sh
. Quando script_due.sh
termina e il controllo ritorna a questo script, le variabili vengono nuovamente visualizzate nel terminale, per verificare se sono cambiate.
Il secondo script si chiama script_due.sh
e viene invocato da script_uno.sh
. Il codice è il seguente:
#!/bin/bash echo "$0: prima_var=$prima_var, seconda_var=$seconda_var" prima_var=gamma seconda_var=delta echo "$0: prima_var=$prima_var, seconda_var=$seconda_var"
Questo script visualizza i valori delle due variabili, poi assegna loro nuovi valori e li visualizza nuovamente.
Per eseguire questi script, rendili eseguibili con:
chmod +x script_uno.sh chmod +x script_due.sh
Esegui ora script_uno.sh
con:
./script_uno.sh
L’output prodotto sarà:
script_uno.sh
visualizza i valori delle variabili, che sono alfa e beta.script_due.sh
visualizza i valori delle variabili (alfa e beta) così come li ha ricevuti.script_due.sh
le modifica in gamma e delta.script_uno.sh
visualizza nuovamente i valori delle variabili, che sono rimasti alfa e beta.
Le modifiche alle variabili effettuate in script_due.sh
sono valide solo all’interno di tale script. È come se al secondo script venisse inviata una copia delle variabili, e queste copie vengano eliminate alla chiusura dello script. Le variabili originali del primo script rimangono invariate.
L’Uso delle Virgolette con le Variabili
Si sarà notato che, quando si fa riferimento alle variabili all’interno degli script, queste sono spesso racchiuse tra virgolette doppie (“”). Questo è necessario per garantire che i valori delle variabili vengano correttamente interpretati e sostituiti quando la riga viene eseguita.
Se il valore assegnato a una variabile contiene spazi, è fondamentale racchiudere l’intero valore tra virgolette durante l’assegnazione. Questo perché, di default, Bash utilizza gli spazi come delimitatori.
Ecco un esempio:
nome_sito=winadmin.it
Bash interpreta lo spazio prima di Geek
come un’indicazione dell’inizio di un nuovo comando, e segnala che tale comando non esiste. Il comando echo
mostra che la variabile nome_sito
è vuota, e non contiene il testo winadmin.it
.
Proviamo di nuovo, racchiudendo tra virgolette l’intero valore:
nome_sito="winadmin.it"
In questo caso, l’intero valore viene correttamente riconosciuto e assegnato alla variabile nome_sito
.
Il Comando Echo: Un Utile Alleato
Potrebbe volerci un po’ di tempo per familiarizzare con la sostituzione dei comandi, l’uso delle virgolette con le variabili e la memorizzazione di quando e come usare il simbolo $
.
Prima di premere Invio ed eseguire un comando Bash, è consigliabile anteporre echo
. In questo modo è possibile visualizzare in anteprima l’effetto del comando, e verificare che si stia per fare ciò che si intende fare. Si possono anche individuare eventuali errori di sintassi.