Bash e script di shellper Svogliati
Lo script da venti righe che ti salva un'ora alla settimana, scritto in modo che non cancelli la cartella sbagliata il giorno che manca una variabile. Virgolette, set -euo pipefail, cicli che non si rompono sugli spazi, e quando smettere e passare a Python.
rm -rf "$CARTELLA"/* — "Tanto CARTELLA è sempre piena." Quella volta era vuota.
Cos'è bash, e perché ti serve
È il programma che legge quello che scrivi nel terminale. Uno script è la stessa cosa, scritta in un file invece che a mano.
Bash non è bello e non è elegante. È il nastro adesivo grigio del sistemista: tiene insieme rsync, tar, curl e systemctl in tre righe, ed è già installato ovunque. Ottimo per tenere insieme altri programmi, pessimo per costruire una casa. Quando lo script comincia a sembrare una casa, è ora di cambiare attrezzo.
Dove brilla
- Lanciare comandi in fila, con qualche controllo in mezzo
- Backup, pulizie, rotazioni, controlli lanciati da un timer
- Preparare una macchina nuova: pacchetti, utenti, file
- Filtrare un log con grep, sort e uniq al volo
Dove soffre
- Strutture dati: liste di liste, dizionari annidati, JSON complicati
- Calcoli con i decimali: bash conosce solo i numeri interi
- Programmi lunghi, con tanti casi e gestione degli errori fine
- Qualunque cosa debba girare uguale anche su Windows
Un po' di storia
Cinquant'anni di shell, e il motivo per cui ogni tanto ti trovi davanti a una che non è bash.
La shell di Thompson
Il primo Unix ha una shell minima: lancia comandi, le redirezioni ci sono, le variabili no. Per programmare non basta.
La Bourne shell
Stephen Bourne, ai Bell Labs, scrive sh: variabili, cicli, condizioni. Il linguaggio degli script nasce qui, e #!/bin/sh viene da lì.
csh e ksh
Bill Joy, a Berkeley, fa la C shell, comoda da usare a mano e scomoda per gli script. David Korn fa la Korn shell, compatibile con Bourne e molto più ricca.
Bash
Il progetto GNU vuole una shell libera. Brian Fox scrive la Bourne Again SHell, il gioco di parole è voluto. Poco dopo la manutenzione passa a Chet Ramey, che la cura ancora oggi.
dash
Ubuntu, e poi Debian, fanno puntare /bin/sh a dash, più piccola e veloce ad avviarsi. Gli script scritti in bash con in testa #!/bin/sh cominciano a rompersi.
Shellshock
Si scopre che bash eseguiva codice nascosto nelle variabili d'ambiente, e il buco c'era da più di vent'anni. Server web con script CGI bucati in tutto il mondo in pochi giorni.
Il Mac passa a zsh, bash va avanti
Con macOS Catalina la shell di default diventa zsh: Apple teneva una bash del 2007 per non accettare la licenza GPLv3. Sui Linux bash resta la regina; la versione 5.3 esce nel 2025.
Bash o qualcos'altro?
La domanda da farsi prima di scrivere la prima riga, non dopo la trecentesima.
| Attrezzo | Quando | Esempio |
|---|---|---|
| Bash | Comandi in fila, poca logica, gira su una macchina Linux | Backup notturno, pulizia dei log, controllo dello spazio |
| Python | Dati strutturati, API, JSON, calcoli, più di un centinaio di righe | Leggere un'API e mandare un riepilogo su Telegram |
| Ansible | La stessa configurazione su tante macchine, ripetibile | Utenti, pacchetti e file uguali su dieci server |
| Un'unità systemd | Un programma che deve restare acceso o partire a orario | Al posto di uno script con while true; do … sleep 60; done |
sed, o a calcolare percentuali con bc in tre posti diversi, lo script ti sta chiedendo di diventare Python. La guida Python è lì.
Il concetto: tutto è testo, e il testo si spezza
Per bash ogni variabile è una stringa, e una stringa senza virgolette viene spezzata sugli spazi e interpretata come caratteri jolly. Quasi tutti i disastri vengono da qui.
Virgolette doppie, sempre
"$file", "$@", "$(comando)". Le togli solo quando vuoi davvero che la stringa venga spezzata, e allora lo scrivi in un commento.
Fermati al primo errore
In testa set -euo pipefail: esci se un comando fallisce, se usi una variabile mai definita, se fallisce un pezzo di una pipe. Ha delle eccezioni, ma è molto meglio di niente (sezione 5).
Fallo leggere a ShellCheck
shellcheck script.sh trova in un secondo le virgolette mancanti e metà degli errori di questa guida. Mettilo nell'editor e non pensarci più.
Lo scheletro di uno script
Copialo, cambia il centro, e metà del lavoro di robustezza è fatta.
#!/usr/bin/env bash
# cosa fa, in una riga: pulisce i backup più vecchi di N giorni
set -euo pipefail
readonly CARTELLA="${1:?uso: $0 CARTELLA [GIORNI]}"
readonly GIORNI="${2:-30}"
log() { printf '%s %s\n' "$(date '+%F %T')" "$*" >&2; }
tmp="$(mktemp -d)"
trap 'rm -rf "$tmp"' EXIT
main() {
[[ -d "$CARTELLA" ]] || { log "non esiste: $CARTELLA"; exit 1; }
log "cancello i file più vecchi di $GIORNI giorni in $CARTELLA"
find "$CARTELLA" -type f -mtime +"$GIORNI" -print -delete
}
main "$@"
| Riga | Perché |
|---|---|
#!/usr/bin/env bash | Usa bash, non sh: su Debian sh è dash, e gli array e [[ ]] non ci sono |
set -e | Esce al primo comando che fallisce |
set -u | Esce se usi una variabile mai definita: un errore di battitura non diventa una stringa vuota |
set -o pipefail | Una pipe fallisce se fallisce un pezzo qualunque, non solo l'ultimo |
${1:?messaggio} | Se manca il primo argomento, si ferma con il messaggio |
${2:-30} | Se manca il secondo, usa 30 |
trap … EXIT | Pulisce i file temporanei comunque finisca, anche con un errore |
>&2 | I messaggi vanno sullo standard error, così non sporcano l'output vero |
set -e non ti proteggeNon scatta per i comandi dentro un if, prima di && o ||, e nelle funzioni chiamate da lì. E local x=$(comando) nasconde l'errore del comando, perché conta il risultato di local: scrivi local x e poi x=$(comando) su due righe.
Variabili e virgolette
Le virgolette semplici bloccano tutto, le doppie lasciano passare solo le variabili. Le altre regole sono dettagli.
nome="Mario Rossi" # niente spazi attorno all'uguale
echo "ciao $nome" # ciao Mario Rossi
echo 'ciao $nome' # ciao $nome, letterale
oggi="$(date +%F)" # il risultato di un comando; i backtick `…` sono la versione vecchia
echo "${nome}_backup" # le graffe quando la variabile è attaccata ad altro testo
export EDITOR=vim # export: la vedono anche i programmi lanciati dallo script
| Scrivi | Ottieni |
|---|---|
${var:-predefinito} | Il valore, o "predefinito" se è vuota |
${var:?errore} | Il valore, o lo script si ferma con "errore" |
${#var} | La lunghezza |
${file%.jpg} | Il nome senza .jpg in fondo |
${percorso##*/} | Solo il nome del file, come basename |
${var//vecchio/nuovo} | Sostituisce tutte le occorrenze |
$(( a + b * 2 )) | Conti con i numeri interi |
server=(web1 web2 "db uno")
for s in "${server[@]}"; do echo "$s"; done # 3 giri, "db uno" resta intero
echo "${#server[@]}" # 3
# opzioni da passare a un comando: un array, non una stringa
opz=(-a --delete --exclude "cartella con spazi")
rsync "${opz[@]}" /srv/ backup:/srv/
for x in $lista fa un solo giro con tutta la stringa, dove bash ne farebbe uno per parola. In più un carattere jolly che non trova niente in zsh è un errore, in bash resta scritto così com'è. Uno script provato a mano nel terminale del Mac può dare "tutto ok" e poi comportarsi in un altro modo sul server. Gli script si provano lanciandoli con bash script.sh, non incollandoli nel terminale.
Condizioni
In bash l'if non controlla un vero o falso: controlla se un comando è finito bene. [[ ]] è solo un comando che fa confronti.
if [[ -f "$conf" && -r "$conf" ]]; then
echo "c'è ed è leggibile"
elif [[ -z "$conf" ]]; then
echo "variabile vuota"
fi
if (( spazio_libero < 10 )); then echo "disco quasi pieno"; fi # numeri: (( ))
if [[ "$host" == web* ]]; then echo "è un web"; fi # caratteri jolly a destra, senza virgolette
if [[ "$ip" =~ ^10\. ]]; then echo "rete interna"; fi # espressione regolare
# l'if su un comando qualsiasi
if grep -q "^$utente:" /etc/passwd; then echo "esiste"; fi
if ! systemctl is-active --quiet nginx; then systemctl restart nginx; fi
| Test | Vero se |
|---|---|
-e / -f / -d | Esiste / è un file / è una cartella |
-r / -w / -x | Leggibile / scrivibile / eseguibile |
-s | Il file esiste e non è vuoto |
-z / -n | La stringa è vuota / non è vuota |
== / != | Stringhe uguali / diverse |
a -nt b | Il file a è più recente di b |
case "${1:-}" in
start|avvia) avvia ;;
stop) ferma ;;
*.tar.gz) estrai "$1" ;;
*) echo "uso: $0 start|stop" >&2; exit 2 ;;
esac
[ ] o [[ ]]?In bash usa [[ ]]: non si rompe se la variabile è vuota o ha spazi, e capisce &&, || e le espressioni regolari. [ ] ti serve solo se scrivi per sh, e allora le virgolette diventano obbligatorie.
Cicli che non si rompono sugli spazi
Il ciclo sbagliato funziona per mesi, poi un giorno arriva "Foto vacanze 2026.jpg".
Così
for f in /srv/foto/*.jpg: il carattere jolly dà già i nomi interiwhile IFS= read -r rigaper leggere un file riga per rigafind … -print0 | while IFS= read -r -d '' fper i nomi con qualunque caratterefor i in {1..10}ofor ((i=0; i<10; i++))per contare
Non così
for f in $(ls): si spezza sugli spazi e sbaglia sui caratteri stranifor riga in $(cat file): non legge righe, legge parolecat file | while read rigasenza-r: mangia le barre rovesciate- Variabili cambiate dentro un
… | whilee lette dopo: la pipe gira in una sottoshell e le perde
# 1. sui file di una cartella; nullglob: se non c'è niente, zero giri invece di "*.log"
shopt -s nullglob
for f in /var/log/app/*.log; do
gzip -- "$f"
done
# 2. riga per riga, con la variabile che sopravvive al ciclo
n=0
while IFS= read -r host; do
[[ -z "$host" || "$host" == \#* ]] && continue
ping -c1 -W1 "$host" >/dev/null || { echo "giù: $host"; n=$((n+1)); }
done < host.txt
echo "$n host giù"
# 3. tutto quello che trova find, anche coi nomi più strani
find /srv -name '*.tmp' -mtime +7 -print0 | while IFS= read -r -d '' f; do
rm -- "$f"
done
Funzioni e codici di uscita
Ogni comando finisce con un numero: 0 vuol dire "tutto bene", qualunque altro vuol dire "qualcosa è andato storto". Su questo numero si regge tutto.
spazio_libero() {
local mount="$1"
df --output=pcent "$mount" | tail -1 | tr -dc '0-9' # il risultato si stampa
}
raggiungibile() {
ping -c1 -W1 "$1" >/dev/null 2>&1 # l'esito è quello dell'ultimo comando
}
usato="$(spazio_libero /)"
if raggiungibile backup.lan; then echo "ok"; fi
| Cosa | Come |
|---|---|
| Gli argomenti | $1, $2…, tutti insieme "$@", quanti sono $# |
| Restituire un valore | Stampalo con echo o printf e prendilo con $( ). return serve solo per l'esito, da 0 a 255 |
| Variabili della funzione | local, sempre: senza, cambi le variabili di tutto lo script |
| L'esito dell'ultimo comando | $?, da leggere subito: il comando dopo lo sovrascrive |
| Fai B solo se A va | A && B |
| Fai B solo se A fallisce | A || B |
A && B || C non è un ifSe A va bene ma B fallisce, parte anche C. Per "se A allora B altrimenti C" scrivi un if vero.
Pipe e redirezioni
Ogni programma ha tre tubi: uno da cui legge, uno su cui scrive i risultati, uno su cui scrive gli errori. Le redirezioni decidono dove vanno a finire.
| Scrivi | Succede |
|---|---|
cmd > file | L'output nel file, che viene svuotato prima |
cmd >> file | L'output in fondo al file |
cmd 2> errori.log | Solo gli errori nel file |
cmd > tutto.log 2>&1 | Output ed errori nello stesso file. L'ordine conta: 2>&1 > file non fa la stessa cosa |
cmd &> /dev/null | Butta via tutto (solo bash) |
cmd < file | Il programma legge dal file |
cmd | tee file | L'output a schermo e nel file insieme |
diff <(cmd1) <(cmd2) | Confronta l'output di due comandi come se fossero file |
# here-doc: le variabili vengono sostituite
cat > /etc/motd <<EOF
Server $(hostname), preparato il $(date +%F)
EOF
# con 'EOF' tra apici il testo resta letterale, utile per scrivere altri script
cat > pulisci.sh <<'EOF'
rm -f "$HOME"/tmp/*.part
EOF
# come root senza aprire una shell root: sudo tee, non sudo echo > file
echo "vm.swappiness=10" | sudo tee /etc/sysctl.d/90-swap.conf >/dev/null
sudo echo … > file non vaLa redirezione la fa la tua shell, non sudo: il file lo apre il tuo utente, prima ancora che sudo parta. Con | sudo tee file è tee, lanciato da root, ad aprirlo.
Lavorare il testo
La forza della shell non è bash: sono i piccoli programmi che metti in fila. Questi sono quelli che usi tutti i giorni.
| Programma | Fa | Esempio |
|---|---|---|
| grep | Tiene le righe che corrispondono | grep -i "error" app.log |
| sed | Cambia il testo al volo | sed 's/vecchio/nuovo/g' |
| awk | Lavora per colonne | awk '{print $1}' access.log |
| cut | Taglia colonne con un separatore fisso | cut -d: -f1 /etc/passwd |
| sort, uniq | Ordina e conta | sort | uniq -c | sort -rn |
| xargs | Trasforma righe in argomenti | find … -print0 | xargs -0 rm |
| jq | Legge e filtra JSON | curl -s api | jq -r '.items[].name' |
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -10
sed -i 's/a/b/' file su Linux modifica il file; sul Mac vuole sed -i '' 's/a/b/' file. Lo stesso vale per date, stat, grep -P e altri. Il perché è nella guida GNU; la soluzione pratica è installare gli strumenti GNU con Homebrew, o provare gli script su Linux.
Script robusti
Uno script che gira da solo di notte deve sopravvivere a quello che tu, sveglio, avresti notato.
🔒 Una copia alla volta
Se il backup delle 3 non ha finito quando parte quello delle 4, si pestano i piedi. flock lo impedisce:
exec 9>/run/lock/backup.lockflock -n 9 || { echo "già in corso"; exit 0; }
⏱️ Un tempo massimo
Un curl o un rsync appesi bloccano tutto per sempre. timeout 300 rsync … lo uccide dopo cinque minuti.
🧪 Prova a vuoto
Un'opzione -n che stampa cosa farebbe senza farlo. Per gli script che cancellano, prima di tutto.
📓 Log nel journal
logger -t backup "fatto in ${SECONDS}s" scrive nel log di sistema; poi lo trovi con journalctl -t backup.
🔁 Rifacibile
Lanciato due volte, deve dare lo stesso risultato: mkdir -p, ln -sf, controlla prima di aggiungere una riga a un file.
📣 Dimmi se fallisce
Uno script notturno che fallisce in silenzio è peggio di nessuno script. Un trap su ERR che manda un messaggio, o un timer systemd con OnFailure=.
set -Eeuo pipefail # la E fa valere il trap ERR anche dentro le funzioni
trap 'avvisa "fallito alla riga $LINENO: $BASH_COMMAND"' ERR
avvisa() { logger -t "$(basename "$0")" -p user.err "$*"; }
rm -rf "$CARTELLA/"* con CARTELLA vuota diventa rm -rf /*. Difese: set -u, ${CARTELLA:?} che si ferma se è vuota, e un controllo esplicito che la cartella sia quella che ti aspetti prima di cancellare.
Debug
Bash non ha un debugger comodo, ma ti racconta ogni passo se glielo chiedi.
bash -n script.sh # controlla la sintassi senza eseguire niente
shellcheck script.sh # gli errori di logica più comuni, con la spiegazione
bash -x script.sh # stampa ogni comando, con le variabili già sostituite
# solo un pezzo: set -x prima, set +x dopo
# con riga e funzione davanti a ogni comando:
PS4='+ ${LINENO}:${FUNCNAME[0]:-main}: ' bash -x script.sh
PATH minimo, senza le tue variabili, senza terminale e da un'altra cartella. Usa percorsi assoluti, imposta il PATH in testa allo script, e prova con env -i bash script.sh, che simula un ambiente vuoto.
Errori tradotti
Quello che dice il messaggio, e quello che vuole dire davvero.
| Messaggio | Vuol dire | Cosa fare |
|---|---|---|
/bin/bash^M: bad interpreter | Il file è stato salvato su Windows, con gli a capo alla Windows | sed -i 's/\r$//' script.sh, o dos2unix |
Permission denied lanciandolo | Manca il permesso di esecuzione, o la cartella è montata noexec | chmod +x script.sh, oppure bash script.sh |
unbound variable | set -u ha trovato una variabile mai definita | Errore di battitura, o un ${var:-} se può mancare davvero |
[: too many arguments | Variabile senza virgolette con spazi dentro, in [ ] | Virgolette, o passa a [[ ]] |
unary operator expected | Variabile vuota senza virgolette in [ ] | Come sopra |
Bad substitution o [[: not found | Lo script gira con sh, cioè dash, non con bash | #!/usr/bin/env bash e niente sh script.sh |
syntax error near unexpected token | Manca un fi, un done, un ;; o una virgoletta prima di quel punto | bash -n e cerca più in alto della riga indicata |
Argument list too long | Il carattere jolly ha trovato centinaia di migliaia di file | find … -delete o find … -print0 | xargs -0 |
command not found solo da cron | Il PATH di cron è minimo | Percorsi assoluti o PATH= in testa |
Cheat sheet
Tutta la guida in una schermata.
| Cosa | Come |
|---|---|
| In testa | #!/usr/bin/env bash e set -euo pipefail |
| Argomento obbligatorio | "${1:?uso: $0 FILE}" |
| Valore predefinito | "${2:-30}" |
| File temporanei | tmp=$(mktemp -d) e trap 'rm -rf "$tmp"' EXIT |
| Leggere righe | while IFS= read -r riga; do …; done < file |
| Liste | arr=(a b "c d") e "${arr[@]}" |
| Output ed errori in un file | > file 2>&1 |
| Una copia alla volta | flock -n |
| Controllo | bash -n, shellcheck, bash -x |
🧘 I cinque comandamenti
- Virgolette doppie, sempre
set -euo pipefailin testa- Mai
for f in $(ls) - ShellCheck prima di lanciare
- Oltre le cento righe, Python
set -euo pipefail in testa, niente for su ls, e passalo a ShellCheck. Se lo script diventa lungo o deve lavorare con JSON e conti, riscrivilo in Python prima che diventi un mostro."