Bash scripting

Versioni Compatibili Tutte le versioni supportate di Debian

Introduzione

Questa non è una guida completa, per la vastità dell'argomento trattato. In particolare non sono trattati alcuni comandi importanti:

• di condizione ed esecuzione condizionata avanzata ([[, ((, case);
• per definire funzioni (... () / function ...);
• per effettuare il parsing degli argomenti (getopts);
• di gestione e invio di segnali (trap, kill);
• di gestione dei file descriptor;
• modificatori di variabili (readonly, local, declare);
• ecc...

Lo scopo della guida è invece, partendo dai concetti più basilari, di evidenziare i comportamenti più distintivi e facili da sbagliare di Bash, con enfasi particolare sulle espansioni di stringhe, estremamente diverse da altri linguaggi di programmazione. Così da poter passare poi a guide più avanzate per completare l'apprendimento dello scripting in Bash.

Le spiegazioni fornite in questa sezione introduttiva su alcuni comandi fondamentali si limitano alla loro sintassi base, così che il loro impiego nelle sezioni successive possa essere facilmente compreso.

Per l'uso interattivo della shell si rimanda a Bash tips. Si noti che l'espansione della history, che qui non è trattata, è attiva soltanto in modalità interattiva.

Come creare uno script

Uno script, per poter essere eseguito come un eseguibile qualsiasi, in ambiente UNIX e Unix-like deve:

• avere il bit di esecuzione attivo;
• iniziare con due caratteri: #! (shebang).

Questo specifica che il file è uno script, ossia non è compilato e direttamente eseguibile, e va eseguito indirettamente invocandone l'interprete con il percorso e le eventuali opzioni scritte sulla stessa riga dello shebang.

Per scrivere uno script in bash basta quindi creare un file con la prima riga che faccia riferimento al percorso della shell:

#! /bin/bash

È consigliato inoltre di determinare esplicitamente il valore di ritorno (exit status) di uno script, facendolo terminare con l'istruzione exit seguita dall'exit status, che è un valore intero compreso tipicamente tra 0 (l'unico valore per successo) e 255. In assenza di tale istruzione il valore di ritorno dello script sarà determinato dall'exit status dell'ultimo comando eseguito.

Inoltre è bene sapere che l'esecuzione di uno script in bash, così come uno in sh (POSIX), di default non è interrotta in presenza di errori. È importante quindi controllare l'exit status dei comandi eseguiti, se possono fallire, con if oppure con gli operatori logici di concantenazione && e ||, che saranno introdotti.

Commenti

È considerato commento tutto ciò che segue il carattere # fino alla nuova riga, purché # non sia racchiuso tra virgolette, apici o preceduto da \, in tal caso mantiene il suo valore letterale.

I commenti sono ovviamente ignorati dall'interprete, ma rendono più leggibile il codice.

Il primo script

Esempio di classico programma che si limita a stampare "Hello world!" sullo schermo:

#! /bin/bash
printf %s\\n "Hello world!"
exit 0

Rendere eseguibile uno script

Una volta scritto lo script, non resta che attivarne il bit di esecuzione. Supponendo si chiami script.sh, da un terminale dare:

$ chmod +x script.sh

E dalla directory in cui si trova è possibile eseguirlo dal terminale con:

$ ./script.sh

Debug integrato

Bash, proprio come dash (la cui sintassi è limitata quasi soltanto alla shell POSIX), ha delle opzioni che ne consentono il debug.

Invocando uno script con -n è possibile effettuare un primitivo controllo di sintassi. Non vengono controllati comandi inesistenti e nemmeno le espansioni, ma può essere utile per verificare che i blocchi sono stati chiusi correttamente prima di eseguire lo script:

$ bash -n script.sh

Altre opzioni utili, che possono essere impiegate anche congiuntamente durante l'esecuzione:

• -x stampa ogni comando prima di eseguirlo;
• -v stampa l'intero blocco di codice che è stato letto (solo la prima volta);
• -u interrompe lo script se si accede a una variabile mai assegnata;
• -e interrompe lo script in caso di errore (se il comando non è controllato da un if, while o dalla concatenazione con ||).

E possono essere usate anche dopo lo shebang nella prima riga dello script. Per esempio:

#! /bin/bash -e

Comandi di output: echo e printf

Il comando echo è largamente diffuso in Bash per stampare delle stringhe su schermo, perché ha una sintassi più semplice di printf e non risente delle stesse limitazioni della shell sh (POSIX), che interpreta ed espande i caratteri di escape (si legga la sezione dedicata) senza che ci sia un modo di stampare letteralmente una stringa (non nota a priori).

Tuttavia negli script l'uso di echo non è sempre possibile, rendendo necessaria la conoscenza almeno basilare di printf. In particolare, se si vuole stampare il contenuto di $var, non è sempre corretto scrivere:

echo -n "$var" # stampa senza a capo finale
echo "$var"    # stampa con a capo finale

perché $var potrebbe iniziare con il carattere "-" ed essere una combinazione delle opzioni: -e, -E, -n.

Con echo non esiste un modo che assicuri la stampa del contenuto di una variabile in ogni situazione possibile. E non sempre il contenuto è noto a priori: in presenza di espansioni, come vedremo poi, o di input dell'utente. Per non incorrere in errori difficili da riconoscere, echo andrebbe usato soltanto nella shell interattiva, dove l'uso è più comodo, e printf andrebbe preferito anche in Bash per gli script, perché ha una sintassi più robusta.

In questa guida d'ora in poi si farà riferimento soltanto a printf.

Uso di printf

Sintassi: printf formato [ "stringa" ... ]

Gli usi più avanzati non sono trattati in questa guida, ma di seguito sono presentati alcuni esempi:

• stampa sullo schermo senza a capo finale

printf %s "stringa da stampare"
printf %s "$var"

• stampa una riga vuota

printf \\n   # corretto (doppio backslash)
printf \n    # ERRORE: stampa 'n'

# tra virgolette
printf "\\n" # corretto (doppio backslash)
printf "\n"  # corretto (singolo backslash)

# tra apici
printf '\\n' # ERRORE: stampa '\n'
printf '\n'  # corretto (singolo backslash)

• altri caratteri speciali nel formato (stesse considerazioni sull'uso di " e ')

printf \\t   # tabulazione
printf \\r   # ritorno a inizio riga
printf \\NNN # stampa il carattere ascii con codice in base 8

• stampa sullo schermo con a capo finale

printf %s\\n "stringa da stampare"
printf %s\\n "$var"

• stampa con a capo prima e dopo

printf \\n%s\\n "stringa" 

Mai stampare una stringa e ancora peggio una variabile senza farla precedere dal formato:

printf "stringa"    # ERRORE: le sequenze speciali inizianti in \ e % verrebbero interpretate!
printf "$var"       # ERRORE: come sopra
printf %s "stringa" # corretto
printf %s "$var"    # corretto

Per usi più complessi, anziché rendere più complicato il formato, è preferibile utilizzare più comandi printf:

# funziona, ma è poco chiaro per chi non ne conosce la sintassi
printf '%s\n\t%s  %s\n' "Sintassi:" "$0" "[ arg ]" # più stringhe

# equivalente, ma più leggibile:
printf %s\\n "Sintassi:"
printf '\t%s\n' "$0  [ arg ]"

Condizioni

Le condizioni nella shell dipendono dal valore di uscita (exit status) di un comando. Si considera successo un exit status corrispondente a 0, ed è equivalente a una condizione vera/soddisfatta, mentre fallimento un exit status con valori diversi da zero, e sono equivalenti a una condizione falsa/non soddisfatta.

Il significato dell'exit status di un comando (successo/fallimento) può essere invertito facendolo precedere da un punto esclamativo (!).

Alcuni comandi hanno un exit status predeterminato:

• : o (equivalentemente) true hanno un exit status sempre di zero (successo/vero);
• false ha un exit status sempre diverso da zero (fallimento/falso).

Per esempio:

:       # exit status 0
true    # equivalente
! :     # exit status diverso da 0
false   # exit status diverso da 0
! false # exit status 0

Espressioni booleane

Le espressioni booleane più basilari, ereditate da POSIX, si possono esprimere con i comandi test e [. L'unica differenza tra i due è che il secondo richiede ] come ultimo argomento, ed è preferibile per questioni di leggibilità del codice. D'ora in poi infatti si considera soltanto [ ... ], e in questa sezione vengono descritte solo le forme più basilari. Per tutte le opzioni supportate si rimanda all'aiuto integrato (help test).

[...] restituisce un exit status di 0 (successo/vero) se la condizione contenuta all'interno è vera, e 1 (fallimento/falso) altrimenti. È molto utile all'interno di istruzioni più complesse, come if per l'esecuzione condizionata e while per eseguire cicli.

Confronti unari con stringhe (tipicamente l'espansione di variabile o parametro):

• [ -z "$var" ]: vero se var contiene una stringa di lunghezza zero o non è definita;
• [ -n "$var" ]: vero se var contiene una stringa che non ha lunghezza zero.

Confronti binari tra stringhe (possono essere anche entrambe variabili):

• [ "$var" = "stringa" ]: vero se il contenuto di var è uguale alla stringa;
• [ "$var" != "stringa" ]: vero se è diverso.

Confronti binari tra stringhe contenenti interi (possono essere anche entrambe variabili):

• [ "$var" -gt valore ]: (greater than) vero se l'intero contenuto nella variabile è maggiore del valore dato;
• [ "$var" -ge valore ]: (greater or equal to) vero se l'intero contenuto nella variabile è maggiore o uguale al valore dato;
• [ "$var" -lt valore ]: (lower than) vero se l'intero contenuto nella variabile è inferiore del valore dato.
• [ "$var" -le valore ]: (lower or equal to) vero se l'intero contenuto nella variabile è inferiore o uguale al valore dato.

Se una delle due stringhe non è un intero, anche negativo, il confronto fallisce e può esserci la stampa di un messaggio d'errore sullo standard error. Per evitarlo va aggiunto 2> /dev/null (il significato di tale redirezione sarà trattato in seguito). Per esempio:

[ "$var" -gt 0 ] 2> /dev/null  # non stampa errori se $var non è un intero

Confronti unari con stringhe contenenti percorsi di file (percorso di default: directory corrente, se mancante):

• [ -e "$var" ]: vero se il file (file regolare, directory, link simbolico, fifo, socket, ... ) esiste;
• [ -f "$var" ]: vero se il file esiste ed è un file regolare;
• [ -d "$var" ]: vero se il file esiste ed è una directory.

Le espressioni più complesse si possono comporre utilizzando gli operatori logici && e || per aggregare più istruzioni [...], e le parentesi { ... ; } per determinarne la priorità, come si vedrà nella parte sui blocchi di istruzioni.

Esecuzione condizionata

Per eseguire un blocco di comandi soltanto se una condizione è soddisfatta si utilizza if, solitamente in combinazione con [...].

La sua sintassi base (in congiunzione con [...]) è:

if [ espressione-booleana ]; then
   ...
[ elif [ espressione-booleana ]; then
   ...               ]  
   ...
[ else ...
   ...               ]
fi

Per esempio:

if [ -z "$var" ]; then
   printf %s\\n "La variabile var è nulla!"
elif [ "$var" = "pluto" ]; then
   printf %s\\n "La variabile var contiene pluto"
else
   printf %s\\n "La variabile var non è nulla e non contiene pluto, ma: ${var}"
fi

Controllo degli errori

Si ricordi che if accetta un comando qualsiasi come condizione, valutandone l'exit status ed eseguendo il ramo then se ha successo, e quello elif/else immediatamente successivo (se presente) altrimenti. Quindi è un ottimo strumento anche per controllare che un comando venga eseguito senza errori, permettendo anche la terminazione immediata dello script:

if comando; then
   printf %s\\n "Comando riuscito!"
else
   printf %s\\n "ERRORE: comando fallito!"
   # esci con errore (exit status 1)
   exit 1
fi

e se si è interessati al solo ramo else, basta utilizzare ! prima del comando:

if ! comando; then
   exit 1
fi

Ciclo condizionato

Per eseguire un blocco di comandi se un comando ha successo e ripeterlo finché il comando continua ad avere successo, si può usare l'istruzione while. Proprio come if è spesso usata in congiunzione con [...] per ripetere un blocco di codice tutte le volte che la condizione espressa è vera.

Sintassi base (in congiunzione con [...]):

while [ espressione-booleana ]
do
   ...
done

Per esempio:

num=
# ripeti finché non è soddisfatta la condizione (si noti il ! davanti a [...])
while ! [ "$num" -gt 0 ] 2> /dev/null
do
   printf %s "Inserisci intero > 0 e premi INVIO: "
   # assegna l'input dell'utente a $num
   read num
done
printf %s\\n "Hai inserito: ${num}"

Oppure si può utilizzare un comando qualsiasi, per esempio per eseguire un ciclo infinito:

while :
do
   ...
done

Un ciclo può essere sempre:

• interrotto da break;
• ripreso dalla prima istruzione del blocco, dopo aver rivalutato l'exit status del comando dopo while, con continue.

Variabili (stringhe)

In Bash ogni variabile di default è trattata come una stringa e, benché Bash supporti anche interi e array (indicizzati o associativi), questa sezione si limita al solo tipo base.

Nomi di variabili

Un nome di variabile ammette soltanto caratteri alfabetici (maiuscoli e minuscoli), l'underscore ('_') e numeri (non in prima posizione). E il suo contenuto si accede con ${nome} oppure con la forma abbreviata $nome.

La forma abbreviata assume che il nome della variabile sia composto da tutti i caratteri validi incontrati. Per esempio la concatenazione "$nome$cognome" è equivalente a "${nome}${cognome}", ma "$nome_$cognome" non lo è a "${nome}_${cognome}" perché nome_ (con underscore finale) sarebbe un nome valido.

Assegnazioni

Non si deve usare il $ davanti alla variabile a cui assegnare. La forma consigliata, salvo necessità particolari, è quella tra virgolette per le stringhe e le concatenazioni di stringhe e variabili, e senza virgolette per una singola variabile:

var="stringa"
var=$var2                   # senza virgolette
var=${var2}                 # equivalente a sopra
var="$var2"                 # come sopra
var="${var1} testo ${var2}" # con virgolette

Altre forme sono possibili, e il loro significato è trattato in seguito:

var=stringa               # assegno una stringa (senza spazi e caratteri speciali)
var=$'stringa con escape' # come sopra, ma con caratteri di escape e senza espansioni
var='stringa senza apici' # niente espansioni, né caratteri di escape
# espansioni...
var=$(comando)            # assegna l'output del comando
var=$(($n * 10))          # assegna il risultato dell'operazione
var=~utente               # assegna la home di utente

Assegnazione dallo standard input

Con l'istruzione read è possibile assegnare a una o più variabili il contenuto di una riga dello standard input, che senza ridirezioni e pipe corrisponde a ciò che viene scritto da tastiera prima di un invio.

Sintassi (base): read nomevariabile [ ... ]

Il nome delle variabili non va preceduto da $, proprio come nelle assegnazioni normali. Se sono presenti più nomi di variabile, la riga letta si divide in stringhe delimitate dai caratteri contenuti in $IFS (di default sono tre: spazio, tabulazione e invio), ma all'ultima variabile viene sempre assegnato tutto il contenuto rimanente fino a fine riga.

Esempio:

printf %s "Scrivi qualcosa e premi invio: "
read testo
printf %s\\n "Hai scritto: ${testo}"

Assegnazione con ciclo

Con l'istruzione for è possibile eseguire un blocco di istruzioni per ogni elemento di una lista di stringhe, assegnando un elemento per volta a una variabile.

Sintassi (base):

for nomevariabile [ in ... ]
do
   ...
done

Al solito il nome della variabile non va preceduto da $. Se la parola riservata in e la lista di stringhe sono omesse, allora è equivalente a: in "$@"

Due modi tipici per generare una lista di stringhe sono:

• con la variabile speciale "$@", l'unica che se quotata si espande a una lista di stringhe;
• con l'espansione di percorso tramite *, che sarà trattata in seguito.

Per esempio:

for file in /percorso/*.txt
do
   if [ -e "$file" ]; then
      # blocco eseguito su ciascun file .txt in /percorso/ tramite "$file"
      ...
   fi
done

Il ciclo for, proprio come while, può essere:

• interrotto dall'istruzione break;
• continuato saltando la corrente iterazione del ciclo con continue, che passa al prossimo elemento della lista, se presente, altrimenti esce.

Espansione di variabile

Con l'unica eccezione dell'assegnazione, quando si accede al contenuto di una variabile senza quotarla, questa può essere trasformata in più di una singola stringa (esplosione) in base agli spazi (e tabulazioni e "a capo") contenuti, e perfino in "niente" se è vuota. "Niente" proprio come se non presente nel codice.

Entrambi i comportamenti non sono intuitivi e costituiscono una comune sorgente di errori. Se si vuole sempre considerare il contenuto della variabile come una singola stringa, è necessario accederla quotata (tra virgolette), ossia con "$variabile" oppure "${variabile}".

Si considerino per esempio i seguenti confronti (usati spesso con if o while):

[ $var = $var2 ]     # SBAGLIATO! (se una delle due è vuota)
[ "$var" = "$var2" ] # corretto
[ -n $var ]          # SBAGLIATO (se var è vuota)
[ -n "$var" ]        # corretto

Ciò è ancora più importante quando si passa la variabile a un comando che agisce su un file indicato dalla variabile, il cui contenuto in presenza di spazi (comuni per i nomi di file degli utenti) potrebbe venir trattato come una lista di file.

Esempio di codice che crea un backup di un file indicato da una variabile:

cp -- "$file" "${file}.bak"

Suggerimento L'opzione "--" dopo il comando esterno cp serve per comunicargli che le stringhe che seguono non sono opzioni, nemmeno se iniziassero con il carattere "-". È sempre buona norma utilizzarla come controllo aggiuntivo con comandi che accettano file come argomenti, il cui nome non è noto a priori, come: rm, rmdir, cp, mv, touch, cat, ecc... L'opzione deve essere supportata dal comando esterno, non è trattata specialmente dalla shell.

D'altra parte accedere una variabile senza quotarla permette di assegnare alla variabile tutte le opzioni da passare a un comando, se sono stringhe senza spazi e caratteri speciali che potrebbero essere espansi nuovamente (* ? [ ]), per poi accederle in una volta sola:

ARGUMENTS="--arg1 --arg2 ..."
...
comando $ARGUMENTS

Si noti che usando "$ARGUMENTS" (quotata) per una variabile contenente la stringa vuota, il comando leggerebbe lo stesso un argomento e potrebbe fallire.

Variabili speciali

$?

contiene il valore di uscita dell'ultimo comando o funzione (0 solo in caso di successo);

$0

contiene il nome usato per lanciare lo script;

$#

contiene il numero di argomenti passati allo script (o a una funzione, all'interno di una funzione);

$1, $2, ...

contengono, se presenti, i parametri passati allo script (o a una funzione);

$@

contiene la lista di tutti i parametri passati allo script corrente o a una funzione. Ogni parametro viene opportunamente quotato, se questa variabile è quotata, e questo ne permette l'utilizzo nei cicli for per processare (ad esempio) una lista di nomi di file che possono contenere anche spazi. L'uso di questa variabile è quindi in genere preferito rispetto a $* che ha la stessa funzione ma, se quotata, non quota i vari parametri ma l'intera stringa;

Esempio:

for file in "$@"
do
    # fare quello che si vuole con "$file"
    ...
done

$$

PID del processo corrente;

$!

PID dell'ultimo job in background.

Esempio:

comando &  # lancio un comando in background
pid=$!     # ottengo il PID del comando
...        # eseguo altre operazioni
wait $pid  # attendo la terminazione del comando
status=$?  # catturo il suo exit status

Caratteri di escape, apici e virgolette

Alcuni caratteri hanno un valore speciale per la shell, per consentire le espansioni o determinati costrutti. Di conseguenza se si intende scrivere il carattere per il suo valore letterale, è necessario comunicarlo alla shell facendolo precedere da un carattere di escape '\' oppure racchiudendolo tra apici o virgolette.

Una stringa non racchiusa tra apici o tra virgolette ha i seguenti caratteri speciali: $ ' ` " \ { } [ ] * ? ~ & ; ( ) < > | #
In determinate circostanze, se non preceduti dal carattere di escape \, possono essere: espansi, eseguiti in background, considerati parte di un nuovo comando, trattati come redirezioni e perfino come commenti. Questa sezione non è esaustiva e non considera tutte le eccezioni, ma consiglia degli accorgimenti che si possono sempre seguire per ridurre il numero di caratteri speciali.

Inoltre gli spazi (comprese le tabulazioni) non quotati con apici o virgolette, e non preceduti dal carattere di escape \, vengono compressi e ciò che è scritto prima o dopo è interpretato come appartenente a stringhe diverse.

Per esempio:

printf %s\\n parola1; parola2      # ERRORE: parola2 è considerata un altro comando!
printf %s\\n "parola1; parola2"    # corretto
printf %s\\n parola1     parola2   # ERRORE: niente spazi e su due righe diverse!
printf %s\\n "parola1     parola2" # corretto

# con una variabile
var="parola1     parola2"          # assegno la stringa alla variabile
printf %s\\n $var                  # ERRORE: stampa le parole su due linee diverse
printf %s\\n "$var"                # stampo la stringa così com'è scritta

Il carattere di escape \ prima di un "a capo", anche se quotato (tra virgolette), ha un significato speciale che consente di scrivere un comando su più righe, trattando ogni riga preceduta da \ come una continuazione della precedente:

# stampa tutto su una riga
printf %s\\n "testo su \
più \
righe"

# stampa su più righe
printf %s\\n "testo su
più
righe"

Racchiudere tra apici

Con gli apici (apostrofi) si riducono i caratteri speciali a uno soltanto, lo stesso apice, rappresentando la stringa per il suo solo valore letterale e impedendo tutte le espansioni:

printf %s\\n '$PATH "" \ `ls ..` \$HOME ~ * .[a-z]*'  # stampa la stringa tra apici, letteralmente

Lo svantaggio è che non esiste un carattere di escape:

printf %s\\n 'L'\''albero di... ' # stampa "L'albero di..." (l'accento non può essere racchiuso tra apici)

Racchiudere tra $'...'

Una stringa racchiusa tra $'...' non può essere espansa in nessun modo, come se fosse racchiusa tra apici. Il carattere \ resta un carattere di escape, quindi è possibile inserire un apice nella stringa facendolo precedere da \ e dev'essere preceduto dal carattere di escape anche ogni \ da stampare letteralmente.

Un carattere \ non preceduto da escape permette di stampare caratteri di escape, con la stessa sintassi del formato di printf (quando racchiuso tra apici):

• \n, nuova riga;
• \b, backspace (cancella un carattere);
• \r, carriage return (ritorna a inizio riga);
• \t, tabulazione;
• \nnn, carattere ASCII in base 8;
• ecc...

Per esempio:

printf %s\\n $'stringa'         # stampa la stringa
printf %s $'stringa\n'          # equivalente: il carattere "a capo" ora è nella stringa
printf %s $'$PATH "" `ls ..`\n' # nessuna espansione
printf %s $'~ * .[a-z]*\n'      # nessuna espansione
printf %s $'{a,b,c} $((2*2))\n' # nessuna espansione
printf %s $'escape: \\\n'       # per stampare un \ dev'essere preceduto da \
printf %s $'L\'albero di...\n'  # stampa "L'albero di..." (l'apice può essere stampato con escape)

È un metodo molto meno diffuso rispetto a racchiudere tra apici e virgolette, perché non derivata da sh (POSIX).

Quotare (tra virgolette)

Racchiudere tra virgolette ogni stringa è raccomandabile, anche se non sempre necessario, così da ridurre il numero di caratteri speciali a cui pensare, permettendo allo stesso tempo l'espansione sicura delle variabili e dei comandi. I soli caratteri speciali rimasti sono $, ` (ma non l'apice), " e \, che devono essere preceduti dal carattere di escape \.

All'interno di una stringa quotata tutte le espansioni che non sono attivabili da $ non sono permesse. Sono possibili soltanto le espansioni di variabile/parametro, di comando e aritmetiche.

Per esempio:

printf %s\\n "$PATH"       # espande la variabile PATH e ne stampa il contenuto
printf %s\\n "\$HOME"      # stampa letteralmente $HOME, senza espanderla (è equivalente a '$HOME')
printf %s\\n "\"\" \\"     # è equivalente a '"" \'
printf %s\\n "$(ls ..)"    # Esegue il comando "ls .." e ne stampa l'output
printf %s\\n "$((2*2))"    # Esegue l'espressione aritmetica e stampa 4
printf %s\\n "~ * .[a-z]*" # non effettua le espansioni di tilda e percorso, ma stampa letteralmente
printf %s\\n "p{a,b,c}s"   # niente espansioni

Espansioni in stringhe quotate

Le espansione attivate da $ avvengono con la stessa priorità, e in una stringa quotata sono le uniche permesse, quindi il risultato di un'espansione non può mai essere espanso un'altra volta. Sono permesse le sole espansioni di variabile, già vista, e di parametro, di comando e aritmetica (intera), che saranno trattate in seguito.

Espansione di parametro (stringa)

È una forma modificata dell'espansione di variabile, che permette di operare sulla stringa contenuta con un modificatore.

L'espansione di parametro è utilizzabile ogni volta che lo è quella di variabile, con un'unica differenza: l'espansione di variabile può essere contenuta in alcune espansioni di parametro, purché non al posto del nome della variabile, mentre non è mai possibile annidare più espansioni di parametro.

Modificatori:

• ${#var} ritorna il numero di caratteri della stringa contenuta in $var. Espande sempre a una singola stringa;
• ${!var} ritorna il contenuto della variabile, il cui nome è contenuto in $var (accesso indiretto);
• espande o assegna valori di default/alternativi;
• manipolatori di stringa (rimozione e sostituzione);
• trasformazione in uppercase / lowercase.

Esempio:

var="stringa"
rif="var"             # rif contiene il nome (senza $) di $var
var2=${!rif}          # equivalente a: var2=$var
printf %s\\n "$var2"  # stampa: stringa
printf %s\\n ${#var2} # stampa: 7 (la lunghezza di "stringa")

Manipolazione delle stringhe

Nelle shell *nix, storicamente, la manipolazione delle stringhe viene fatto attraverso programmi esterni alla shell come sed, awk e perl. Questi programmi vengono ancora usati quando si vuole mantenere la compatibilità con la shell sh (POSIX) o per manipolazioni molto complesse.

Se si usa Bash non è necessario usare nessun programma esterno, ma basta imparare i tre operatori fondamentali ed alcuni concetti di base, per poter fare tutte le manipolazioni più comuni direttamente sulle variabili.

Si assegna una stringa a una variabile e accedendola tramite la forma con le graffe, si può ricorrere a un modificatore che manipola la stringa (senza modificare il contenuto della variabile), ad esempio:

VAR="stringa-di-esempio"
printf %s\\n "${VAR#stringa-}"

ritorna il contenuto della variable VAR senza il prefisso "stringa-". VAR non viene modificata, salvo una nuova assegnazione:

VAR=${VAR#stringa-}

ora il prefisso "stringa-" è stato eliminato anche dalla variabile VAR.

I modificatori sono molti, ma possono essere facilmente ricordati se si imparano i tre fondamentali:

• # sottrae dall'inizio della stringa (minimale);
• % sottrae dalla fine della stringa (minimale);
• / sostituisce una sottostringa con un'altra (solo la prima volta che viene incontrata).

Questi operatori sono minimali, questo vuol dire che se si usano le espressioni regolari per indicare la sottostringa (da eliminare o sostituire) verrà individuata in caso di ambiguità la sottostringa più piccola (o solo la prima nel caso della sostituzione).

Per ottenere gli operatori massimali basta raddoppiare il simbolo:

• ## sottrae dall'inizio della stringa (massimale);
• %% sottrae dalla fine della stringa (massimale);
• // sostituisce una sottostringa con un'altra (tutte le volte che viene incontrata).

Gli operatori massimali cercano di individuare la sottostringa più grande che corrisponde all'espressione regolare (nel caso del modificatore // tutte le sottostringhe vengono sostituite).

Si noti che le stringhe interne a un'espansione di parametro possono essere delle variabili, ma non altre espansioni di parametro:

# cambia l'estensione nella variabile file
if [ "$file" != "${file%${estensione}}" ]; then
   file=${file%${estensione}}${nuova_estensione}
fi

Per una spiegazione dettagliata di tutti i modificatori e anche di altri modi di manipolare le stringhe in Bash (ad esempio expr) vedere:

• Advanced Bash-Scripting Guide: Manipulating Strings

Esempi: manipolazione delle stringhe

VAR="questa.sarebbe.una.stringa.di.esempio"
  
                             # Risultato:
  
printf %s\\n "${VAR#*.}"     # --> sarebbe.una.stringa.di.esempio
printf %s\\n "${VAR##*.}"    # --> esempio
  
printf %s\\n "${VAR%.*}"     # --> questa.sarebbe.una.stringa.di
printf %s\\n "${VAR%%.*}"    # --> questa
  
printf %s\\n "${VAR/st/ST}"  # --> queSTa.sarebbe.una.stringa.di.esempio
printf %s\\n "${VAR//st/ST}" # --> queSTa.sarebbe.una.STringa.di.esempio

Esempio: alternativa a basename

Quando in uno script ci si deve riferire al nome dello script stesso, è usuale utilizzare il comando esterno basename. Una possibile alternativa:

usage () {
   printf %s\\n "Usage: ${0##*/}"
}

Espansione di comando

Consiste nel trasformare l'output di un comando qualsiasi (interno della shell, esterno, una funzione e anche forme composte) in argomenti per un altro comando, oppure nel valore da assegnare a una variabile. Si effettua racchiudendo un comando tra $(...):

$(comando)

oppure, meno leggibile e sconsigliata tra `...` (su tastiera con layout italiano: Alt Gr + '):

`comando`

Inoltre la prima forma può essere annidata facilmente, mentre la seconda richiederebbe un livello aggiuntivo di escape.

L'output del comando consiste in zero, una o più stringhe: in base agli spazi presenti nell'output prodotto, e in maniera analoga all'espansione a cui sono soggette le variabili. Per trasformare l'output di un comando in una singola stringa è necessario che l'espansione di comando sia quotata, con l'eccezione dell'assegnazione a una variabile.

Esempi di assegnazione:

# assegna alla variabile $oggi la data in formato YYYY_MM_DD
oggi=$(date '+%F')   # senza virgolette
oggi="$(date '+%F')" # equivalente a sopra (non servono nelle assegnazioni)

# associo a testo la dimensione in bytes di $file
testo=$(wc -c -- $file)     # SBAGLIATO! (se la variabile $file contiene spazi o caratteri speciali)
testo=$(wc -c -- "$file")   # le virgolette attorno alla variabile sono necessarie
testo="$(wc -c -- "$file")" # equivalente a sopra
# testo contiene anche altre stringhe, ma sono interessato solo alla prima
bytes=${testo%% *}          # estraggo il primo argomento (espansione di parametro)

Passaggio dell'output dei comandi come argomento:

# stampa stati
printf %s\\n "Login name: $(logname); Name: $(whoami); UID: $(id -ur); EUID: $(id -u); Groups: $(groups)"
printf %s\\n "OS: Debian GNU/Linux $(cat /etc/debian_version) ($(lsb_release -sc))" # uguale a $(lsb_release -sd)
printf %s\\n "Kernel: $(uname) $(uname -r) ($(uname -v))"

Output con a capo finali

Si noti che l'espansione di comando, come anche in sh (POSIX), non espande il comando a tutto l'output prodotto, ma omette sempre gli "a capo" finali. Se da una parte è utile nella maggior parte delle situazioni, può talvolta avere effetti collaterali difficili da prevedere. Si consideri per esempio:

printf %s\\n ciao > ./file_prova # scrive ciao e un "a capo" nel file_prova
testo=$(cat ./file_prova)        # associa il contenuto (SENZA "a capo") a $testo
printf %s\\n "Bytes: ${#testo}"  # NON è la dimensione esatta del file!
printf %s\\n "$testo" |          # invia la stringa a cmp (più un "a capo") per un confronto
  cmp - ./file_prova             # nessun errore!!!
printf %s\\n $?                  # infatti stampa 0

ATTENZIONE Una variabile non può contenere il carattere ASCII numero 0, quindi per i file binari è sempre sbagliato accederli in questo modo. È sconsigliabile anche se non si è certi della loro dimensione, e se si è interessati soltanto alla prima riga si può utilizzare: read riga < file_prova

Un altro esempio, vogliamo associare il carattere "a capo" a una variabile:

nr="
"                    # funziona, ma occupa più righe e rompe l'indentazione
nr=$'\n'             # funziona (con Bash) ed è il modo consigliato

# a titolo esemplicativo per l'espansione di comando
nr=$(printf \\n)     # SBAGLIATO, $nr è vuota
nr="$(printf \\n)"   # SBAGLIATO, $nr è sempre vuota

# una possibile soluzione...
nr=$(printf \\n%s X) # $nr contiene "a capo" seguito da X
nr=${nr%X}           # $nr contiene "a capo" (la X è rimossa)

# Attenzione che il carattere aggiunto dev'essere nell'output del comando
nr="$(printf \\n)X"  # SBAGLIATO, $nr contiene solo X

Espansione aritmetica intera

Permette di compiere operazioni aritmetiche tra interi, ritornando sempre una singola stringa contenente l'intero risultante. Può essere quotata, ma non cambia niente.

La sintassi è: $((...))
All'interno delle parentesi è possibile utilizzare:

• le quattro operazioni: + - * /
• resto/modulo: %
• potenza: **
• variabili da espandere (contenenti valori interi)
• parentesi per cambiare le priorità degli operatori: ( )

Esempio:

base=9
altezza=5
area=$(($base * $altezza))
printf %s\\n "Area rettangolo: ${area}"       # Stampa 45
printf %s\\n "Area triangolo: $(($area / 2))" # Stampa 22 (RICORDA: solo interi)

Espansioni non quotabili

Le espansioni trattate nelle sezioni successive avvengono unicamente in stringhe non quotate, almeno limitatamente ai caratteri speciali che le attivano, e sono attivabili soltanto da caratteri diversi dal $.

Le loro priorità sono tutte diverse: l'espansione di parentesi è quella maggiore, seguita dalla tilda, da tutte le espansioni attivabili con $ (quelle quotabili) e infine dall'espansione di percorso.

Inoltre l'espansione di tilda, che è sempre espansa in una singola stringa, è l'unica possibile in un'assegnazione tra le espansioni non quotabili.

Espansione di tilda

Sintassi:

• ~ si espande alla home, se non è quotata (equivalente all'uso di $HOME, che può essere quotata);
• ~utente si espande alla home di un dato utente, se esiste, ma la stringa non può essere quotata né essere una variabile.

Si distingue dall'espansione di percorso perché:

• si espande sempre a una singola stringa;
• può essere espansa in un'assegnazione, se non è quotata;
• ha priorità maggiore delle espansioni quotabili; per cui, se assegnata quotata a una variabile, non sarà espansa quando si accede alla variabile.

Esempi:

var=~                # assegno la home dell'utente a $var
var=$HOME            # equivalente (ma più chiaro)
var="~"              # assegno ~ a $var
printf %s\\n "$var"  # stampo ~
printf %s\\n $var    # equivalente (nessuna espansione)
var=~root            # assegno a var la home di root
printf %s\\n ~       # stampo la home dell'utente
printf %s\\n "$HOME" # equivalente
printf %s\\n "~"     # stampo ~
printf %s\\n ~root   # stampo la home di root
printf %s\\n ~fdsfd  # stampo ~fdsfd (l'utente fdsfd non esiste)

Espansione di percorso

File Su UNIX e Unix-like per file si può intendere sia un file regolare, ma anche una directory, un link simbolico, una pipe, un socket, un device, ecc...

Le espansioni di percorso sono possibili solo se i caratteri speciali che la consentono (* ? [ ]) non sono racchiusi tra virgolette, apici o preceduti da /. È sempre consigliabile racchiudere tutto il resto tra virgolette, per non permettere espansioni accidentali.

L'espansione non è possibile, direttamente, in un'assegnazione. Avendo la priorità più bassa, contrariamente all'espansione di tilda può avvenire anche in seguito all'espansione di una variabile (e con ogni altra espansione), se non è quotata:

var="./*"           # assegno ./* a $var
var=./*             # come sopra (nessuna espansione in un'assegnazione)
printf %s\\n "$var" # stampa letteralmente ./*
printf %s\\n $var   # stampa la lista di tutti i file non nascosti
                    # nella directory corrente, oppure ./* se è vuota

Sintassi (prefisso e suffisso possono essere omessi, o essere variabili da espandere):

• prefisso?suffisso sostituisce un singolo carattere di un file, con tutti quelli possibili che combaciano con le due stringhe date, ma di default tranne il . iniziale se manca il prefisso;
• prefisso*suffisso può sostituire tutti i caratteri di un file, ma di default tranne quelli nascosti se manca il prefisso (ossia quelli inizianti con .).

Esempi (nella directory corrente):

• file.??? si espande a tutti i file con nome "file" e con una qualsiasi estensione di tre caratteri;
• * da solo espande a tutti i file non nascosti nella directory corrente. È sempre buona norma far precedere l'asterisco da un ./, che indica la cartella corrente, se non c'è un percorso assoluto o con tilda, per impedire espansioni di file inizianti con "-", che potrebbero essere visti come opzioni da alcuni comandi;
• ./* equivalente a * ma più sicuro; di seguito si userà per tutte le espansioni (riguardanti la directory corrente);
• ./*.txt espande a tutti i file con estensione .txt;
• ./*."${estensione}" espande dopo aver espanso la variabile (contrariamente a ~), che può anche essere quotata;
• "./${nome}"* espande a tutti i file inizianti con $nome;
• ./*/ espande a tutte le directory non nascoste;
• ./.* espande a tutti i file nascosti (ATTENZIONE: comprese "." e "..", ossia directory corrente e superiore).

È importante sapere che, se nessun file combacia con un dato pattern, allora l'espansione non viene effettuata e i caratteri mantengono il loro valore letterale. E inoltre * e ? sono caratteri validi per un nome di file.

L'esistenza di file ottenuti da tali espansioni va pertanto sempre controllata, per esempio con il costrutto [ -e "$file" ]:

for file in ./*; do
   if [ -e "$file" ]; then
      ...
   fi
done

In alternativa, il comportamento di default dell'espansione può essere cambiato (in Bash), tramite shopt:

• dotglob espande ai file nascosti;
• nullglob espande a "niente" se non trova nessun file con un dato pattern, rendendo superfluo il controllo sull'esistenza.

Per esempio:

shopt -s dotglob nullglob
for file in ./*; do
   ...
done

Esempio: cambiare l'estensione ai file

Rinomina tutti i file *.txt della directory corrente in *.log:

for f in ./*.txt; do
   if [ -e "$f" ]; then
      mv -- "$f" "${f%txt}log"
   fi
done

Espansione di parentesi (graffa)

Se i caratteri { e } non sono quotati, e non sono preceduti dal carattere di escape \, possono essere espansi con due diverse sintassi per generare una lista di stringhe. E più espansioni di parentesi possono essere annidate.

Questa espansione avviene prima di tutte le altre, e il risultato può passare per tutte le altre espansioni. Non può avvenire in un'assegnazione, se non all'interno di altre espansioni.

Con indici di intervallo

Sintassi: prefisso{x..y[..z]}suffisso

L'espansione avviene per tutte le stringhe nell'intervallo compreso da "prefissoxsuffisso" fino a "prefissoysuffisso", con incrementi di 1 (o z se specificato). Le stringhe prefisso e suffisso possono essere omesse, o essere variabili (anche quotate, purché le graffe non lo siano), mentre x e y (e z, se presente) devono essere determinati valori e non possono essere variabili:

• {x..y} dove x e y sono due interi;
• {x..y..z} dove x, y e z sono tre interi;
• {a..b} dove a e b sono due caratteri;
• {a..b..z} dove a e b sono due caratteri, e z è un intero.

Per esempio:

# crea un file temporaneo, associa il percorso a $tmp_file
tmp_file=$(tempfile)
# crea altri dieci file temporanei (.0, .1, .., .9) con lo stesso nome
touch -- "$tmp_file".{0..9}

Con lista di stringhe

Sintassi: prefisso{stringa1,stringa2,...}suffisso

L'espansione avviene per tutte le stringhe nella lista, racchiudendole tra il prefisso e il suffisso dati, se presenti. Il prefisso, il suffisso e tutte le stringhe possono essere variabili, anche quotate, purché non siano quotate le graffe e le virgole interne.

Questa espansione è effettuata prima di tutte le altre, e il risultato dell'espansione se non quotato può quindi subire ulteriori espansioni. Per esempio per effettuare un'operazione sui file nella cartella corrente che hanno una data estensione, si può scrivere:

for file in ./*.{odt,abw,txt,rtf,doc}; do
   if [ -e "$file" ]; then
      ...
   fi
done

e la prima riga è equivalente a:

for file in ./*.odt ./*.abw ./*.txt ./*.rtf ./*.doc; do

Istruzioni composte

Rientrano in questa sezione tutte le istruzioni composte da una o più istruzioni più semplici.

Redirezione

Alcune comuni redirezioni (la lista non è esaustiva), da scriversi dopo un comando:

• > file dopo un comando ne scrive l'output sul file (troncandolo, se esiste);
• >> file aggiunge al file (creandolo, se non esiste);
• < file legge l'input dal file;
• >&2 scrive l'output sullo standard error;
• 2> file scrive lo standard error sul file (per aggiungere al file: 2>>);
• 2>&1 scrive lo standard error sullo standard output;
• &> file invia standard output ed error sul file (per aggiungere: &>>);
• |  : pipe che invia l'output del comando precedente al successivo. Tutti i comandi di una serie di pipe (anche l'ultimo) sono eseguiti in una subshell, e possono stare su righe diverse con la pipe come ultimo carattere.

Esempi:

comando &> /dev/null     # non stampa niente a schermo, neanche gli errori
comando > /dev/null 2>&1 # equivalente (POSIX)

# filtra le occorrenze di video
dmesg | grep -i video

Output dei comandi e carattere ASCII n. 0

Una variabile non può contenere il carattere ASCII n. 0, che è usato per indicare la fine della stringa. Non potendo gestire direttamente il carattere ASCII n. 0, questo non può essere presente nell'espansione di un comando, ma dev'essere lasciato a comandi esterni mediante l'uso di una o più pipe.

Infatti non esiste un modo di contenere il carattere ASCII n. 0 in nessuna posizione:

var=$'\000'   # SBAGLIATO: $var è vuota
var=$'X\000X' # SBAGLIATO: $var contiene XX

Questo carattere è utile perché nemmeno i file possono averlo nel proprio nome, mentre invece permettono caratteri jolly (*, ?, ...), come già visto con le espansioni di percorso, e potrebbero contenere perfino il carattere "a capo".

L'espansione di percorso funziona normalmente, anche in presenza di "a capo", ma potrebbero sorgere problemi sfruttando l'espansione di comando. Per esempio con il comando esterno find, utilizzato per effettuare ricerche in modo ricorsivo, e che di default restituisce i file trovati stampandoli uno per riga, assumendo implicitamente che non contengano il carattere "a capo".

Uno script a titolo esemplificativo:

# creo una directory e un file con "a capo" nel nome
mkdir ./prova
touch ./prova/"file contenente"$'\n'"a capo nel nome"

# SBAGLIATO! (per via del nome del file particolare)
num_file=$(find ./prova -type f | # stampo i file regolari nella directory, uno per riga
           wc -l)                 # conto il numero di righe 

printf %s\\n "La directory prova contiene ${num_file} file" # restituisce 2 invece di 1

# forma corretta
num_file=$(find ./prova -type f -print0 | # stampo il carattere ASCII n. 0 dopo ogni file
	   tr -dc '\000' |                # rimuovo tutti i caratteri ASCII diversi dal n. 0
           wc -c)                         # conto il numero di caratteri

printf %s\\n "La directory prova contiene ${num_file} file" # restituisce 1

# pulizia
rm -- ./prova/file*nome  # elimino il file
rmdir -- ./prova         # elimino la directory (se vuota)

Un abbinamento comune al comando esterno GNU find (dotato dell'opzione -print0) è il comando esterno GNU xargs (dotato dell'opzione -0):

find /percorso -opzione1 ... -opzioneN -print0 | # trova file che soddisfano le condizioni date
xargs -0 comando [ argomenti ... ]               # li passa come argomenti a un comando esterno

Si leggano i rispettivi manuali per maggiori informazioni. find ha la possibilità di eseguire altri comandi esterni sui file trovati direttamente con le opzioni -exec ed -execdir, ma la sintassi è più complessa e non supporta più di un processo per volta, come invece xargs.

Concatenazione e blocchi di comandi

Più comandi, anche contenenti redirezioni, possono essere concatenati per formarne di più complessi. L'operatore di concatenazione può essere anche l'ultimo di una riga, per facilitare la leggibilità del codice.

;

separatore di comandi, con cui un comando verrà eseguito a prescindere dal successo del precedente (in uno script è equivalente a un "a capo" e questa è la concatenazione di default)

&

separatore che esegue il comando precedente in background (ritorna exit status sempre positivo e non riceve input da tastiera), passando al successivo

&&

operatore logico AND, che va posizionato tra due comandi, il secondo dei quali è eseguito solo se il primo ha esito positivo

Esempio:

cd /percorso/dir && comando

Attenzione invece alla pericolosità di:

cd /tmp/tmpdir # cambia la cartella corrente in /tmp/tmpdir
# ma se fallisce, quello successivo verrebbe eseguito comunque!
rm -- ./*      # cancella tutti i file nella directory corrente

||

operatore logico OR, il secondo comando è eseguito solo se il primo ha effetto negativo (si può usare anche dopo una sequenza di &&, perché ha priorità inferiore):

{ ... ; }

esegue un blocco di comandi (dopo l'ultimo servono ";" o un "a capo"). È usata nelle funzioni ed è utile per concatenare && e ||:

# interrompe la catena se un comando fallisce
cd /tmp/tmpdir &&
rm -- ./* &&
rmdir -- /tmp/tmpdir || {
   # il blocco è eseguito solo se un comando fallisce
   retval=$?
   printf %s\\n "ERRORE (exit status: $retval)" >&2
   exit $retval
}

( ... )

esegue il blocco di comandi in una subshell (le variabili vengono ripristinate al loro valore precedente, alla fine del blocco).

Catturare l'exit status

Per catturare lo stato d'uscita di un comando appena eseguito è sufficiente espandere la variabile speciale $?, come già visto. Tuttavia in caso di fallimento del comando, il controllo effettuato via $? avverrebbe soltanto dopo un blocco con errore (si veda la parte introduttiva sul debug).

Per evitare che un blocco abbia un exit status diverso da zero, si possono usare le concatenazioni && e || (oppure un if):

comando &&
status=0 || # se corretto
status=$?   # se sbagliato

Link

• Bash Referece Manual: manuale ufficiale
• Advanced Bash-Scripting Guide: la Bibbia dello bash scripting.

---

Guida scritta da: ~ The_Noise (in Bash tips)	Debianized 60%
Estesa da: S3v (in Bash tips) HAL 9000
Verificata da: S3v (in Bash tips) HAL 9000 13:24, 16 lug 2014 (CEST)
Verificare ed estendere la guida | Cos'è una guida Debianized