10 Suggerimenti Essenziali per Script Bash ad Alte Prestazioni

Le prestazioni degli script Bash di solito si riducono a una cosa: quanto lavoro chiedi alla shell di fare un processo alla volta. Uno script che funziona bene per dieci file può diventare dolorosamente lento quando scorre cinquantamila file e avvia sed, grep o chmod una volta per elemento.

Usa questi suggerimenti quando il tuo script gestisce molti file, analizza grandi output di testo o viene eseguito abbastanza spesso da far accumulare piccoli ritardi.

---

1. Riduci al Minimo l'Invio di Comandi Esterni

Ogni volta che Bash esegue un comando esterno (es. grep, awk, sed), crea un nuovo processo, il che comporta un overhead sostanziale. Il modo più efficace per velocizzare uno script è utilizzare i built-in di Bash quando possibile.

Preferisci i Built-in agli Strumenti Esterni

Esempio: Invece di usare test o [ esterni per i controlli condizionali:

Lento (Esterno)	Veloce (Built-in)
if test -f "$FILE"; then	if [[ -f "$FILE" ]]; then

Suggerimento: Per le operazioni aritmetiche, usa sempre (( ... )) invece di expr o let, poiché l'espansione aritmetica è gestita internamente dalla shell.

# Lento
COUNT=$(expr $COUNT + 1)

# Veloce (Espansione aritmetica built-in)
(( COUNT++ ))

2. Usa Costrutti di Ciclo Efficienti

I cicli for tradizionali che iterano sull'output di un comando possono essere lenti a causa della creazione di processi o problemi di word splitting. Usa l'espansione nativa delle parentesi graffe o i cicli while read correttamente.

Evita for i in $(cat file)

Usare $(cat file) legge l'intero file in memoria prima e poi lo sottopone a word splitting, il che è inefficiente e soggetto a errori se i nomi dei file contengono spazi. Usa invece un ciclo while read per l'elaborazione riga per riga:

# Metodo preferito per elaborare file riga per riga
while IFS= read -r line;
do
    echo "Elaborazione: $line"
done < "data.txt"

Nota su IFS= read -r: Impostare IFS= impedisce il taglio degli spazi iniziali/finali, e -r impedisce l'interpretazione dei backslash, garantendo l'integrità dei dati.

3. Elabora i Dati Internamente con l'Espansione dei Parametri

Bash fornisce potenti funzionalità di espansione dei parametri (come rimozione di sottostringhe, sostituzione e conversione di maiuscole/minuscole) che operano internamente sulle stringhe, evitando strumenti esterni come sed o awk per compiti semplici.

Esempio: Rimuovere un Prefisso

Se devi rimuovere il prefisso log_ da una variabile filename:

filename="log_report_2023.txt"

# Lento (sed esterno)
# new_name=$(echo "$filename" | sed 's/^log_//')

# Veloce (Espansione built-in)
new_name=${filename#log_}
echo "$new_name" # Output: report_2023.txt

4. Memorizza nella Cache gli Output di Comandi Costosi

Se esegui lo stesso comando costoso (es. chiamare un'API, scoperta complessa di file) più volte all'interno di uno script, memorizza il risultato in una variabile o in un file temporaneo invece di eseguirlo ripetutamente.

# Esegui questo solo una volta all'inizio
GLOBAL_CONFIG=$(get_system_config_from_db)

# Gli usi successivi leggono direttamente la variabile
if [[ "$GLOBAL_CONFIG" == *"DEBUG_MODE"* ]]; then
    echo "Modalità debug attiva."
fi

5. Usa Variabili Array per le Liste

Quando hai a che fare con liste di elementi, usa gli array di Bash invece di stringhe separate da spazi. Gli array gestiscono correttamente gli elementi che contengono spazi e sono generalmente più efficienti per l'iterazione e la manipolazione.

# Lista di stringhe lenta/soggetta a errori
# FILES="file A fileB.txt"

# Array veloce e robusto
FILES_ARRAY=( "file A" "fileB.txt" "another file" )

# Iterazione efficiente
for f in "${FILES_ARRAY[@]}"; do
    process_file "$f"
done

6. Evita Virgolette eccessive e Rimozione di Virgolette

Sebbene una corretta virgolettatura sia cruciale per la correttezza (specialmente quando si gestiscono nomi di file con spazi), virgolette eccessive e la loro rimozione possono talvolta aggiungere un overhead minore. Ancora più importante, capisci quando le virgolette sono obbligatorie rispetto a quando sono opzionali.

Per l'espansione aritmetica ((...)), le virgolette generalmente non sono necessarie intorno all'espressione stessa, a differenza della sostituzione di comando $().

7. Usa la Sostituzione di Processo per il Pipelining Dove Possibile

La sostituzione di processo (<(cmd)) a volte può creare pipeline più pulite e veloci rispetto alle named pipe (mkfifo), specialmente quando devi inviare l'output di un comando a due parti diverse di un altro comando simultaneamente.

# Confronta i contenuti di due file ordinati in modo efficiente
if cmp <(sort file1.txt) <(sort file2.txt); then
    echo "I file sono identici quando ordinati."
fi

8. Usa printf Invece di echo

Sebbene spesso trascurabile, il comportamento di echo può variare tra shell e sistemi, richiedendo talvolta una gestione più complessa per l'interpretazione dei backslash. printf offre una formattazione coerente e un controllo superiore, rendendolo generalmente più affidabile e talvolta leggermente più veloce per operazioni di output ad alto volume.

# Output coerente
printf "Utente %s ha effettuato l'accesso alle %s\n" "$USER" "$(date +%T)"

9. Preferisci find ... -exec ... {} + a -exec ... {} ;

Quando usi il comando find per eseguire un altro programma sui file trovati, la differenza tra terminare con un punto e virgola (;) rispetto a un segno più (+) è enorme per le prestazioni.

• {} ; esegue il comando una volta per file. (Overhead elevato)
• {} + raggruppa quanti più argomenti possibile ed esegue il comando una volta (come xargs). (Overhead basso)

# Lento: Esegue 'chmod 644' migliaia di volte
find . -name '*.txt' -exec chmod 644 {} \;

# Veloce: Esegue 'chmod 644' una o poche volte con molti argomenti
find . -name '*.txt' -exec chmod 644 {} +

10. Usa awk o perl per l'Elaborazione Pesante di Testo

Sebbene l'obiettivo sia ridurre al minimo le chiamate esterne, quando è richiesta un'elaborazione di testo complessa e pesante, strumenti specializzati come awk o perl sono significativamente più veloci rispetto a concatenare più comandi grep, sed e cut. Questi strumenti elaborano i dati in un unico passaggio.

Se ti ritrovi a scrivere cat file | grep X | sed Y | awk Z, consolida tutto in un unico script awk ottimizzato.

---

La Regola Pratica

Gli script Bash veloci fanno meno lavoro all'interno dei cicli Bash. Usa i built-in della shell per test semplici e modifiche alle stringhe, raggruppa le operazioni sui file con find -exec ... {} + o xargs, e passa a awk, perl o un altro parser reale quando l'elaborazione del testo diventa il compito principale.

Prima di ottimizzare, misura un'esecuzione rappresentativa con time o il tracing della shell. Poi correggi i cicli che generano il maggior numero di comandi.