Bash scripting - comandi essenziali

Bash scripting

Sommario

Introduzione Comandi essenziali Variabili (stringhe) Caratteri di escape, apici e virgolette Espansioni in stringhe quotate Espansioni non quotabili Istruzioni composte Funzioni File descriptor e redirezioni Segnali

I comandi introdotti in questa sezione sono descritti solo limitatamente alla loro sintassi base, così che il loro impiego nelle sezioni successive possa essere facilmente compreso.

La lettura della sezione può essere tralasciata, se si hanno già nozioni basilari di bash, ma la parte sui comandi di output serve anche a giustificare la scelta di printf in luogo del più noto echo come unico comando di output e a spiegarne brevemente la sintassi, almeno per le invocazioni più comuni.

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

Stampa di messagi d'errore

Per i messaggi di errore, benché sia possibile stamparli assieme ai messaggi normali (sullo standard output), è conveniente utilizzare lo standard error che ne permette la gestione separata. Se nessuna redirezione è specificata, saranno comunque stampati a schermo a prescindere dall'uso di standard output, che è implicito, o standard error.

Il significato delle redirezioni sarà trattato in seguito in un capitolo apposito della guida. Per ora e per buona parte della guida basti sapere che per stampare messaggi di errore è sufficiente aggiungere >&2 al termine dell'istruzione printf.

Per esempio:

printf %s\\n "ERRORE: il file specificato non esiste!" >&2  # standard error

Sovrascrivere echo

Se non si riesce a fare a meno di echo si può sovrascriverlo per gli usi più basilari, così da utilizzare al suo posto printf in modo trasparente, mettendo queste definizioni in cima allo script subito dopo lo shebang:

# sovrascrivo echo
# stampa su schermo con "a capo" finale
echo () { printf %s\\n "$*" ; }

# rimpiazzo per echo -n
# stampa su schermo senza "a capo" finale)
echo_n () { printf %s "$*" ; }

Per esempio:

#! /bin/bash

# sovrascrivo echo
echo () { printf %s\\n "$*" ; }

# al posto di echo -n
echo_n () { printf %s "$*" ; }

# ora si può usare echo (echo_n) al posto di printf %s\\n (printf %s)

echo "Hello World!"   # stampa: Hello World!
echo_n "Hello world!" # stampa: Hello world! (senza "a capo")
echo -n               # stampa: -n
echo -e               # stampa: -e

exit 0

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).

Il comando [...] 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.

Su bash si può usare anche == al posto di =, per chi ha familiarità con la sintassi dei confronti C-like, ma non è POSIX.

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

• [ "$var" -eq valore ]: (equal to) vero se l'intero contenuto nella variabile è uguale al valore dato;
• [ "$var" -ne valore ]: (not equal to) vero se l'intero contenuto nella variabile non è uguale al valore dato;
• [ "$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:

# Controlla che la variabile sia un intero non negativo
[ "$var" -ge 0 ] 2> /dev/null      # non stampa errori se $var non è un intero
# Controlla che la variabile sia un intero qualsiasi
[ "$var" -eq "$var" ] 2> /dev/null # fallisce solo se $var non è intero

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

• [ -b "$var" ]: vero se il file è un dispositivo a blocchi;
• [ -c "$var" ]: vero se il file è un dispositivo a caratteri;
• [ -d "$var" ]: vero se il file esiste ed è una directory;
• [ -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;
• [ -g "$var" ]: vero se è impostato il bit sgid;
• [ -G "$var" ]: vero se l’id di gruppo del file è uguale al vostro;
• [ -h "$var" ]: vero se il file esiste ed è un link simbolico;
• [ -k "$var" ]: vero se è impostato lo “sticky bit”;
• [ -L "$var" ]: vero se il file esiste ed è un link simbolico;
• [ -N "$var" ]: vero se il file è stato modificato dall’ultima lettura;
• [ -O "$var" ]: vero se si è il proprietario del file;
• [ -p "$var" ]: vero se il file è una pipe (FIFO);
• [ -r "$var" ]: vero se il file esiste e l'utente corrente ha il permesso di lettura;
• [ -s "$var" ]: vero se il file non è vuoto;
• [ -S "$var" ]: vero se il file è un socket;
• [ -t "$var" ]: vero se il file è associato a un terminale;
• [ -u "$var" ]: vero se è impostato il bit suid;
• [ -w "$var" ]: vero se il file esiste e l'utente corrente ha il permesso di scrittura;
• [ -x "$var" ]: vero se il file esiste e l'utente corrente ha il permesso di esecuzione (o accesso per le directory).

Confronti binari con stringhe contenenti percorsi di file:

• [ "$var1" -nt "$var2" ]: vero se il file $var1 è più recente di $var2;
• [ "$var1" -ot "$var2" ]: vero se il file $var1 è più vecchio di $var2;
• [ "$var1" -et "$var2" ]: vero se i file $var1 e $var2 sono degli hard link allo stesso file;

Con il punto esclamativo ! (NOT) si inverte il senso dei precedenti confronti.

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!" >&2  # stampa sullo standard error
   # 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