10 Astuces Essentielles de Script Bash pour des Performances Maximales

Les performances des scripts Bash se résument généralement à une chose : la quantité de travail que vous demandez au shell d'effectuer un processus à la fois. Un script qui semble acceptable pour dix fichiers peut devenir douloureusement lent lorsqu'il boucle sur cinquante mille fichiers et lance sed, grep ou chmod une fois par élément.

Utilisez ces astuces lorsque votre script traite de nombreux fichiers, analyse de grandes sorties textuelles ou s'exécute assez souvent pour que de petits retards s'accumulent.

---

1. Minimisez l'Invocation de Commandes Externes

Chaque fois que Bash exécute une commande externe (par exemple, grep, awk, sed), il crée un nouveau processus, ce qui entraîne une surcharge importante. Le moyen le plus efficace d'accélérer un script est d'utiliser les fonctions intégrées de Bash autant que possible.

Privilégiez les Fonctions Intégrées aux Utilitaires Externes

Exemple : Au lieu d'utiliser test ou [ externes pour les vérifications conditionnelles :

Lent (Externe)	Rapide (Intégré)
if test -f "$FILE"; then	if [[ -f "$FILE" ]]; then

Astuce : Pour les opérations arithmétiques, utilisez toujours (( ... )) au lieu de expr ou let, car l'expansion arithmétique est gérée en interne par le shell.

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

# Rapide (Expansion arithmétique intégrée)
(( COUNT++ ))

2. Utilisez des Structures de Boucle Efficaces

Les boucles for traditionnelles qui itèrent sur la sortie d'une commande peuvent être lentes en raison de la création de processus ou de problèmes de découpage de mots. Utilisez l'expansion native des accolades ou les boucles while read correctement.

Évitez for i in $(cat file)

Utiliser $(cat file) lit tout le fichier en mémoire d'abord, puis le soumet au découpage de mots, ce qui est inefficace et sujet aux erreurs si les noms de fichiers contiennent des espaces. Utilisez plutôt une boucle while read pour un traitement ligne par ligne :

# Méthode préférée pour traiter les fichiers ligne par ligne
while IFS= read -r line;
do
    echo "Traitement : $line"
done < "data.txt"

Remarque sur IFS= read -r : Définir IFS= empêche la suppression des espaces de début/fin, et -r empêche l'interprétation des barres obliques inverses, garantissant l'intégrité des données.

3. Traitez les Données en Interne avec l'Expansion des Paramètres

Bash fournit des fonctionnalités puissantes d'expansion des paramètres (comme la suppression de sous-chaînes, la substitution et la conversion de casse) qui opèrent en interne sur les chaînes, évitant les outils externes comme sed ou awk pour les tâches simples.

Exemple : Suppression d'un Préfixe

Si vous devez supprimer le préfixe log_ d'une variable filename :

filename="log_report_2023.txt"

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

# Rapide (Expansion intégrée)
new_name=${filename#log_}
echo "$new_name" # Sortie : report_2023.txt

4. Mettez en Cache les Sorties de Commandes Coûteuses

Si vous exécutez la même commande coûteuse (par exemple, appeler une API, une découverte complexe de fichiers) plusieurs fois dans un script, mettez le résultat en cache dans une variable ou un fichier temporaire au lieu de le réexécuter à plusieurs reprises.

# Exécutez ceci une seule fois au début
GLOBAL_CONFIG=$(get_system_config_from_db)

# Les utilisations suivantes lisent la variable directement
if [[ "$GLOBAL_CONFIG" == *"DEBUG_MODE"* ]]; then
    echo "Mode débogage actif."
fi

5. Utilisez des Variables de Type Tableau pour les Listes

Lorsque vous traitez des listes d'éléments, utilisez des tableaux Bash au lieu de chaînes séparées par des espaces. Les tableaux gèrent correctement les éléments contenant des espaces et sont généralement plus efficaces pour l'itération et la manipulation.

# Chaîne de liste lente/sujette aux erreurs
# FILES="file A fileB.txt"

# Tableau rapide et robuste
FILES_ARRAY=( "file A" "fileB.txt" "another file" )

# Itération efficace
for f in "${FILES_ARRAY[@]}"; do
    process_file "$f"
done

6. Évitez les Guillemets Excessifs et le Déquotage

Bien qu'un guillemetage correct soit crucial pour l'exactitude (en particulier lors de la manipulation de noms de fichiers avec des espaces), un guillemetage et un déquotage excessifs peuvent parfois ajouter une surcharge mineure. Plus important encore, comprenez quand les guillemets sont obligatoires par rapport à facultatifs.

Pour l'expansion arithmétique ((...)), les guillemets ne sont généralement pas nécessaires autour de l'expression elle-même, contrairement à la substitution de commande $().

7. Utilisez la Substitution de Processus pour le Pipelinage Lorsque Possible

La substitution de processus (<(cmd)) peut parfois créer des pipelines plus propres et plus rapides que les tubes nommés (mkfifo), en particulier lorsque vous devez alimenter la sortie d'une commande dans deux parties différentes d'une autre commande simultanément.

# Comparez le contenu de deux fichiers triés efficacement
if cmp <(sort file1.txt) <(sort file2.txt); then
    echo "Les fichiers sont identiques une fois triés."
fi

8. Utilisez printf au Lieu de echo

Bien que souvent négligeable, le comportement de echo peut varier entre les shells et les systèmes, nécessitant parfois une gestion plus complexe pour l'interprétation des barres obliques inverses. printf offre un formatage cohérent et un contrôle supérieur, ce qui le rend généralement plus fiable et parfois marginalement plus rapide pour les opérations de sortie à volume élevé.

# Sortie cohérente
printf "Utilisateur %s connecté à %s\n" "$USER" "$(date +%T)"

9. Préférez find ... -exec ... {} + à -exec ... {} ;

Lorsque vous utilisez la commande find pour exécuter un autre programme sur les fichiers découverts, la différence entre la terminaison par un point-virgule (;) et un signe plus (+) est massive pour les performances.

• {} ; exécute la commande une fois par fichier. (Forte surcharge)
• {} + regroupe autant d'arguments que possible et exécute la commande une fois (comme xargs). (Faible surcharge)

# Lent : Exécute 'chmod 644' des milliers de fois
find . -name '*.txt' -exec chmod 644 {} \;

# Rapide : Exécute 'chmod 644' une ou quelques fois avec de nombreux arguments
find . -name '*.txt' -exec chmod 644 {} +

10. Utilisez awk ou perl pour le Traitement Lourd de Texte

Bien que l'objectif soit de minimiser les appels externes, lorsqu'un traitement de texte lourd et complexe est nécessaire, des outils spécialisés comme awk ou perl sont significativement plus rapides que l'enchaînement de plusieurs commandes grep, sed et cut. Ces outils traitent les données en un seul passage.

Si vous vous retrouvez à écrire cat file | grep X | sed Y | awk Z, consolidez cela en un seul script awk optimisé.

---

La Règle Pratique

Les scripts Bash rapides font moins de travail à l'intérieur des boucles Bash. Utilisez les fonctions intégrées du shell pour les tests simples et les modifications de chaînes, regroupez les opérations sur fichiers avec find -exec ... {} + ou xargs, et passez à awk, perl ou un autre analyseur réel lorsque le traitement de texte devient la tâche principale.

Avant d'optimiser, mesurez une exécution représentative avec time ou le traçage du shell. Ensuite, corrigez les boucles qui génèrent le plus de commandes.