Bash scripting

Versioni Compatibili Tutte le versioni supportate di Debian

Introduzione

In questa sezione verranno elencati alcuni brevi tip per lo scripting Bash. Questa non vuole essere assolutamente una guida completa, ma piuttosto un elenco di costrutti per lo scripting bash particolarmente eleganti, curiosi e/o poco noti. Si cercherà anche di fornire consigli utili sui comportamenti più distintivi di Bash, partendo dai più facili da fraintendere.

Per l'uso interattivo si rimanda invece a Bash tips.

Variabili

In Bash ogni variabile (di default) è trattata come una stringa. E il contenuto di una variabile si accede con ${nome} oppure con la forma abbreviata $nome.

Nomi di variabili

Come nella maggior parte dei linguaggi di programmazione, un nome di variabile ammette soltanto caratteri alfabetici (maiuscoli e minuscoli), l'underscore "_" e numeri (questi ultimi purché non in prima posizione).

Si noti che la forma abbreviata considera il nome della variabile come composto da tutti i caratteri validi incontrati. Per esempio "$nome$cognome" è equivalente a "${nome}${cognome}", ma "$nome_$cognome" non lo è a "${nome}_${cognome}" perché nome_ (con underscore finale) sarebbe un nome di variabile valido. In caso di concatenazione di variabili è preferibile accedere alle variabili con le graffe, o in alternativa (meno elegante) delimitarle dalle virgolette; infatti "$nome"_"$cognome" corrisponde a "${nome}_${cognome}".

Assegnazioni

Nelle assegnazioni non si deve usare il $ davanti al nome della variabile, salvo che per accedere al contenuto di altre variabili:

 variabile=stringa                         # assegno un valore (una stringa senza spazi e caratteri speciali)
 variabile="stringa con spazi"             # assegno una stringa con spazi (con caratteri speciali preceduti da '\')
 variabile='stringa senza apici'           # assegno una stringa contenente spazi e caratteri speciali (ma non apici)
 variabile=$altra_variabile                # assegno una variabile
 variabile=${altra_variabile}              # equivalente a sopra
 variabile="$altra_variabile"              # equivalente a sopra (non serve quotare nelle assegnazioni)
 variabile='$altra_variabile'              # si assegna letteralmente $altra_variabile (e non il suo contenuto)
 variabile="\$altra_variabile"             # come sopra, perché $ è preceduto da \
 variabile="${var1} testo ${var2}_${var3}" # assegno una concatenazione di variabili e stringhe

I caratteri speciali (", `, $ e \) nelle stringhe quotate (tra virgolette) devono essere preceduti dal carattere di escape \, mentre le stringhe racchiuse tra apici possono contenere tutti i caratteri ma non l'apice, come si vedrà più avanti.

È possibile anche assegnare stringhe su più righe:

 variabile="stringa
su più
righe"

Espansione di una 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 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 in genere con if, while, ...):

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

Questo fatto è ancora più importante quando si passa la variabile a un comando, in particolare se questo 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, se il suo nome non termina già con estensione .bak. Si notino le virgolette attorno alla variabili, omesse solo nelle assegnazioni (senza spazi), per garantire che ogni variabile venga espansa in uno e un solo argomento:

 if [ "$file" = "${file%.bak}" ]; then
    oldfile=$file
    file=${file}.bak
    cp -- "$oldfile" "$file"
 fi

D'altra parte accedere una variabile senza quotarla permette di assegnare tutte le opzioni da passare a un comando, se sono stringhe senza spazi, alla variabile per poi accederle in una volta sola:

ARGUMENTS="" # nell'intestazione del file, solo opzioni senza spazi
...
comando $ARGUMENTS # la variabile, non quotata, può essere vuota (come non scritta) o essere espansa in uno o più argomenti

Si noti invece che usando "$ARGUMENT" (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. Il comando ha successo se restituisce zero, qualsiasi altro valore indica invece un codice di errore;

Esempio:

$ cd ..
$ echo $?
0

$ cd ...
$ echo $?
1

$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
    echo "$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  # riporto il comando in foreground

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), tuttavia imparare anche il solo sed (il più semplice dei tre) non è cosa immediata.

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"
echo ${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). Gli operatori di questo tipo vengono comunemente chiamati anche greedy (ingordi).

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:
  
  echo ${VAR#*.}      # --> sarebbe.una.stringa.di.esempio
  echo ${VAR##*.}     # --> esempio
  
  echo ${VAR%.*}      # --> questa.sarebbe.una.stringa.di
  echo ${VAR%%.*}     # --> questa
  
  echo ${VAR/st/ST}   # --> queSTa.sarebbe.una.stringa.di.esempio
  echo ${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 a bash) basename. Tuttavia, tramite i modificatori del paragrafo precedente, Bash stessa è in grado di fornire questa funzionalità. Basta usare l'espressione ${0##*/}.

usage () {
        echo "usage: ${0##*/} "
        exit 1
}

Caratteri di escape, apici e virgolette

Alcuni caratteri hanno un valore speciale per la shell, per consentirne le espansioni (di variabile, parametro, comando, percorso, ecc...). Di conseguenza se si intende scrivere un carattere speciale senza espanderlo, è necessario comunicarlo alla shell facendolo precedere da un carattere di escape '\' oppure racchiudendolo tra apici o virgolette (a seconda dell'espansione da disattivare).

Una stringa non racchiusa tra apici o tra virgolette ha i seguenti caratteri speciali: ', ", `, $, \, {, [, *, ?, ~. Se non preceduti dal carattere di escape \ possono, in base ai caratteri immediatamente successivi, essere espansi. Questa sezione non è esaustiva, ma consiglia qualche semplice accorgimento, in particolare riguardo l'uso di apici e virgolette per ridurre le necessità dell'escape.

Inoltre gli spazi (comprendendo tabulazioni e a capo) non quotati vengono compressi:

echo parola1     parola2   # stampa parola1 parola2 con un singolo spazio
echo "parola1     parola2" # stampa mantenendo gli spazi tra le due parole

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 la continuazione del comando precedente:

# stampa tutto su una riga con un singolo comando echo
echo "testo su \
più \
righe, tutto stampato \
su una singola riga, come scritto \
tutto di seguito grazie all'uso di \\, \
ma si noti che \\ dev'essere l'ultimo carattere"

# stampa su più righe (sempre con un singolo comando)
echo "testo su
più
righe, stampato
su più righe, così com'è scritto"

Racchiudere tra apici

Racchiudendo tra apici (apostrofi) una stringa, si riducono i caratteri speciali a uno soltanto, ossia lo stesso apice, rappresentando la stringa per il suo solo valore letterale e impedendo tutte le espansioni. Lo svantaggio è che non esiste un carattere di escape, e che quindi un apice non può essere racchiuso tra apici in alcun modo. Per esempio:

echo '$PATH "" \ `ls ..` \$HOME ~ * .[a-z]*'  # stampa la stringa tra apici, così com'è scritta

echo 'L'\''albero di... ' # stampa "L'albero di..." (l'accento non può essere racchiuso tra apici e va preceduto da \)

Quotare (racchiudere tra virgolette)

Racchiudere tra virgolette (ossia quotare) ogni stringa è in genere raccomandabile e la scelta consigliata, così da ridurre drasticamente il numero di caratteri speciali, permettendo allo stesso tempo l'espansione delle variabili e dei comandi. I soli caratteri speciali sono $, ` (ma non l'apice), " e \, che devono essere preceduti dal carattere di escape \. Le espansioni di percorso e tilda (*, ?, [...], ~, ... ) non sono possibili; mentre lo sono quelle di variabile e parametro (attraverso un $ senza \), e quelle di comando (attraverso un ` o un $( senza \).

Riprendendo l'esempio e considerandolo per parti:

echo "$PATH"       # espande la variabile PATH e ne stampa il contenuto.
echo "\"\" \\"     # è equivalente a '"" \', si noti l'uso dei \ con le virgolette.
echo "`ls ..`"     # Esegue il comando "ls .." e ne stampa l'output. È equivalente a "$(ls ..)".
echo "\$HOME"      # stampa letteralmente $HOME, senza espanderla. È equivalente a '$HOME'.
echo "~ * .[a-z]*" # non effettua le espansioni di tilda e percorso, ma stampa letteralmente.

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 $(...), oppure tra due apici gravi `...` (su tastiera con layout italiano: Alt Gr + '):

$(comando)

oppure, meno leggibile e sconsigliata:

`comando`

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 il contenuto del file indicato da $file
testo=$(cat $file)     # SBAGLIATO! (se la variabile $file contiene spazi o caratteri speciali)
testo=$(cat "$file")   # le virgolette attorno alla variabile sono necessarie
testo="$(cat "$file")" # equivalente a sopra

Esecuzione dei comandi e passaggio come argomento del loro output:

# stampa stati
echo "Login name: $(logname); Name: $(whoami); UID: $(id -ur); EUID: $(id -u); Groups: $(groups)"
echo "OS: Debian GNU/Linux $(cat /etc/debian_version) ($(lsb_release -sc))" # uguale a $(lsb_release -sd)
echo "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:

echo ciao > file_prova # scrive ciao (più un "a capo") nel file_prova
testo=$(cat file_prova)     # associa il contenuto (senza "a capo") a $testo
echo "Lunghezza del file: ${#testo}" # non è la dimensione esatta del file
echo "$testo"               # stampa il contenuto di $testo (più un "a capo")

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:

nuova_riga="
"                          # funziona, ma è brutto esteticamente e non permette l'indentazione
nuova_riga=$'\n'           # funziona (con Bash) ed è il modo consigliato

# a titolo esemplicativo con l'espansione di comando
nuova_riga=$(echo)         # SBAGLIATO, $nuova_riga è vuota
nuova_riga="$(echo)"       # SBAGLIATO, come sopra
nuova_riga=$(printf "\n")  # SBAGLIATO, $nuova_riga è sempre vuota
# una possibile soluzione...
nuova_riga=$(printf "\nX") # $nuova_riga contiene "a capo" seguito da X
nuova_riga=${nuova_riga%X} # $nuova_riga contiene "a capo" (la X è rimossa)
# Attenzione che il carattere aggiunto dev'essere nell'output del comando
nuova_riga=$(printf "\n")X # SBAGLIATO, $nuova_riga contiene solo X

Espansione di tilda e percorso

File Si ricordi per le espansioni che su ambienti 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...

Non racchiudere tra virgolette e apici serve a permettere le espansioni di percorso e tilda. È sempre consigliabile racchiudere tutto il resto tra virgolette, per non permettere espansioni accidentali. In particolare si noti che un'espansione di percorso (ma non di tilda) può avvenire anche in base al contenuto di una variabile, se questa non è quotata.

Per esempio:

var=*       # assegno * alla variabile
var="*"     # è equivalente a sopra
echo "$var" # stampa letteralmente *
echo $var   # stampa la lista di tutti i file non nascosti
            # nella directory corrente, oppure * se è vuota
var=~       # assegno ~ alla variabile
echo "$var" # stampa letteralmente ~
echo $var   # equivalente a sopra, nessuna espansione

Le espansioni più comuni sono:

• ~ (tilda) espande alla home (equivalente alla variabile $HOME, che però può essere quotata);
  • ~utente espande alla home di un dato utente, ma la stringa utente non può essere quotata né essere una variabile da espandere;
• ? pattern per un singolo carattere di un file;
  • nomefile.??? combacia con tutti i file con nome "nomefile" e terminanti con tre caratteri qualsiasi per estensione;
• * pattern per tutti i possibili caratteri di un file (di default tranne quelli inizianti con .):
  • * 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 è il primo carattere del pattern, per impedire espansioni di file inizianti con "-", che potrebbero essere visti come opzioni da alcuni comandi;
  • ./* equivalente a * ma più sicuro; di seguito si aggiunge il prefisso della directory corrente a tutte le espansioni inizianti con *;
  • ./*.txt espande a tutti i file con estensione .txt;
  • ./*/ espande a tutte le directory non nascoste;
  • prefisso*suffissoespande a tutti i file con un dato prefisso e suffisso;
  • ./*."${estensione}" espande dopo aver espanso la variabile (contrariamente a ~), che può anche essere quotata.

È importante tenere presente per le espansioni di percorso che, se nessun file combacia con un dato pattern, allora l'espansione non viene effettuata e i caratteri mantengono il loro valore originale. Inoltre * e ? sono caratteri validi per un nome di file, e un confronto sull'espansione ottenuta non sarebbe necessariamente risolutivo.

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

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

Suggerimento L'opzione "--" dopo il comando esterno mv 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, in particolare per comandi che manipolano i file come: rm, cp, mv, ecc... L'opzione deve essere supportata dal comando esterno, non è trattata specialmente dalla shell.

Espansione di parentesi (graffa)

Se i caratteri { e } non sono quotati, e non sono preceduti dal carattere di escape \, in determinate circostanze possono essere espansi.

L'espansione supporta due forme: una iterativa, da espandere in un intervallo da un indice a un altro, e una dichiarativa, da espandere nei valori della lista fornita. La prima espansione sostituisce spesso la necessità di ricorrere al comando esterno seq, utilizzato da sh (POSIX).

Con indici di intervallo

prefisso{x..y[..z]}suffisso espande iterativamente a tutte le stringhe a partire da "prefissoxsuffisso" fino a "prefissoysuffisso", con incrementi di 1 (o z se specificato). Le stringhe prefisso e suffisso possono essere omesse, e anche essere variabili (anche quotate, purché le graffe non lo siano), mentre x, y e z devono essere determinati valori:

• {x..y} dove x e y sono due interi (non possono essere variabili);
• {x..y..z} dove x, y e z sono tre interi (non possono essere variabili);
• {a..b} dove a e b sono due caratteri (non possono essere variabili);
• {a..b..z} dove a e b sono due caratteri, e z è un intero (non possono essere variabili).

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}
# operazioni varie con i file
# ...

# pulizia prima di terminare lo script
rm -- "$tmp_file" "$tmp_file".{0..9}

Con lista di stringhe

prefisso{stringa1,stringa2,...}suffisso espande a 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

che è equivalente a:

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

Concatenazione e redirezione

&&

operatore logico AND, il secondo comando verrà eseguito solo se il primo avrà esito positivo

;

separatore di comandi, il secondo comando verrà eseguito in ogni caso (in uno script è equivalente a un "a capo" e questa è la concatenazione di default)

$ cd ... && echo done
$ cd ... ; echo done

Nel caso specifico di un'applicazione che resta in esecuzione il secondo comando non verrà eseguito finché il primo non sarà terminato, in questo caso si usa & e saranno eseguiti entrambi in quanto il primo comando viene mandato in background; prendiamo xterm come esempio:

$ xterm && xterm -rv
$ xterm ; xterm -rv
$ xterm & xterm -rv

|

pipe, passa l'output del comando che la precede come input del comando che la segue

$ ls -A1 | less

||

operatore logico OR, restituisce esito positivo se almeno una delle condizioni di verifica valutate è vera

$ if [ -f ~/.bashrc ] || [ -d ~/.config ]; then echo 'w00t!'; else echo 'no such file or directory'; fi

$ if [ -f ~/.bashrc ] || [ -d ~/.configs ]; then echo 'w00t!'; else echo 'no such file or directory'; fi

$ if [ -f ~/.bash ] || [ -d ~/.configs ]; then echo 'w00t!'; else echo 'no such file or directory'; fi

• Advanced Bash-Scripting Guide: Special Characters

Dirige output di comando su file:

$ man xterm > xterm.txt

Dirige output di errore su file:

$ xterm 2> xterm-errors.log

Entrambi su file diversi:

$ xterm > xterm_out.log 2> xterm_err.log

Entrambi sullo stesso file:

$ xterm &> xterm.log

Entrambi sullo stesso file, alternativa:

$ xterm > xterm.log 2>&1

Appende nuovo testo a quello già presente in un file:

$ man uxterm >> xterm.txt

Cancella contenuto di un file:

$ :> xterm.txt

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=$(printf '\000')     # SBAGLIATO: $var è vuota
var=$(printf '\000X')    # SBAGLIATO: $var contiene solo X
var=$(printf 'X\000X')   # SBAGLIATO: $var contiene XX
var="$(printf 'X\000X')" # SBAGLIATO: equivalente a sopra

L'utilità di questo carattere si deve in particolare al fatto che nemmeno i file possono averlo nel proprio nome, mentre invece permettono caratteri jolly (*, ?, ...) come abbiamo già visto con le espansioni di percorso, e potrebbero contenere perfino 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 

echo "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

echo "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 ... ]               # passa questi file al comando

Si leggano i rispettivi manuali per maggiori informazioni (man find e man xargs).

Debug integrato

Bash, proprio come dash, ha delle opzioni che ne consentono il debug.

Per iniziare invocando uno script con -n è possibile effettuare un primitivo controllo di sintassi. Si noti che possibili comandi inesistenti non vengono controllati e nemmeno le espansioni (di variabili, percorsi, ecc...), ma può essere utile per verificare che tutti i blocchi sono stati chiusi correttamente prima di eseguire lo script:

$ bash -n script.sh

Dopo questo primo controllo ci sono altre opzioni utili, che possono essere impiegate anche congiuntamente nell'esecuzione dello script:

• -x invia sull'output per gli errori ogni comando prima di eseguirlo, preceduto da un prompt "+ ";
• -v invia sull'output per gli errori l'intero blocco di codice che è stato letto (solo la prima volta);
• -u interrompe l'esecuzione dello script se si accede a una variabile che non è mai stata assegnata, può essere utile in caso di errori di battitura;
• -e interrompe lo script in caso un comando ritorni un errore, se il suo valore di ritorno non è controllato da un if, while, until o dalla concatenazione di comandi con ||.

Le opzioni possono essere anche accorpate:

$ bash -evx script.sh

L'opzione -e può essere utilizzata anche fuori dal debug, ma è consigliabile non fare affidamento sulla sua presenza nella prima riga dello script (#! /bin/bash -e), visto che può essere ignorata semplicemente invocando la shell con lo script come argomento oppure importando il contenuto dello script. I valori di ritorno di ogni comando che può fallire vanno invece controllati nel codice.

Link

Link ad altre risorse su GNU Bash:

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

---

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