Dépannage efficace des problèmes d'expansion de variables Bash

L'expansion de variables Bash est le mécanisme central qui permet aux scripts d'utiliser des données dynamiques. Lorsqu'un script lit une variable (par exemple, $MY_VAR), le shell substitue le nom par sa valeur stockée. Bien que cela semble simple, des problèmes subtils liés aux guillemets, à la portée et à l'initialisation sont responsables d'une part importante des erreurs de script Bash.

Ce guide explore en profondeur les pièges les plus courants de l'expansion des variables, en fournissant des solutions concrètes et des meilleures pratiques pour garantir que vos scripts s'exécutent de manière fiable et prévisible, éliminant ainsi les comportements inattendus causés par des données manquantes ou des transformations non intentionnelles.

1. Gestion des variables non initialisées ou nulles

L'une des erreurs les plus fréquentes dans les scripts Bash est de s'appuyer sur une variable qui n'a pas été explicitement définie ou initialisée. Par défaut, Bash étend silencieusement une variable non définie en une chaîne vide, ce qui peut entraîner des échecs catastrophiques du script si cette variable est utilisée dans des opérations de fichiers ou des commandes critiques.

L'option `nounset` : Échec rapide

La mesure préventive la plus importante est d'activer l'option nounset, qui force le script à se terminer immédiatement s'il tente d'utiliser une variable non définie (mais non nulle).

#!/bin/bash
set -euo pipefail

echo "La variable est : $MY_VAR" # <-- Le script échouera ici si MY_VAR n'est pas défini

# Sans set -u, cela aurait silencieusement passé une chaîne vide :
# echo "La variable est : "

Meilleure pratique : Commencez toujours les scripts critiques par set -euo pipefail.

Définition de valeurs par défaut

Lorsqu'une variable peut légitimement être non définie ou nulle, vous pouvez utiliser des modificateurs d'expansion de paramètres pour fournir une valeur de secours.

Modificateur	Syntaxe	Description
Par défaut (Non vide)	`${VAR:-default}`	Si `VAR` est non défini ou nul, développer en `default`. `VAR` lui-même reste inchangé.
Assignation (Persistante)	`${VAR:=default}`	Si `VAR` est non défini ou nul, assigner `default` à `VAR` puis développer cette valeur.
Erreur/Sortie	`${VAR:?Message d'erreur}`	Si `VAR` est non défini ou nul, afficher le message d'erreur et quitter le script.

Cas d'utilisation d'exemple

# Utiliser un répertoire d'entrée fourni, ou par défaut './input'
INPUT_DIR=${1:-./input}

echo "Traitement des fichiers dans : $INPUT_DIR"

# S'assurer que la clé API requise est présente, sinon quitter
API_KEY_CHECK=${API_KEY:?Erreur : API_KEY doit être défini dans l'environnement.}

2. Guillemets : Prévenir le fractionnement de mots et le globbing

Un mauvais usage des guillemets est la plus grande source de bogues d'expansion de variables. Lorsqu'une variable est développée sans guillemets ($VAR), le shell effectue deux étapes cruciales sur la valeur résultante :

Fractionnement de mots (Word Splitting) : La valeur est divisée en plusieurs arguments en fonction de l'IFS (Internal Field Separator, généralement espace, tabulation, saut de ligne).
Globbing : Les mots résultants sont vérifiés pour des caractères génériques (*, ?, []) et développés en noms de fichiers s'ils correspondent.

L'importance des guillemets doubles

Pour empêcher le fractionnement de mots et le globbing, utilisez toujours des guillemets doubles autour des expansions de variables, en particulier celles contenant des entrées utilisateur, des chemins ou des sorties de commandes.

PATH_WITH_SPACES="/tmp/My Data Files/reports.log"

# ❌ Problème : La commande voit 4 arguments au lieu d'un seul chemin
# mv $PATH_WITH_SPACES /destination/

# ✅ Solution : La commande voit 1 argument (le chemin complet)
# mv "$PATH_WITH_SPACES" /destination/

Attention : Bien que les guillemets doubles suppriment le fractionnement de mots et le globbing, ils autorisent toujours l'expansion de variables ($VAR) et la substitution de commandes ($()).

Quand utiliser les guillemets simples

Les guillemets simples ('...') suppriment toute expansion. Utilisez-les uniquement lorsque vous avez besoin de la chaîne littérale telle qu'elle est tapée, empêchant le shell d'évaluer des caractères spéciaux comme $, \ ou `.

# $USER est développé à l'intérieur des guillemets doubles
echo "Bonjour, $USER"
# Sortie : Bonjour, johndoe

# $USER est traité littéralement à l'intérieur des guillemets simples
echo 'Bonjour, $USER'
# Sortie : Bonjour, $USER

3. Comprendre la portée et les limites des sous-shells

Les scripts Bash invoquent souvent des fonctions ou exécutent des commandes dans des sous-shells. Comprendre comment les variables sont partagées (ou non) à travers ces frontières est essentiel pour un dépannage efficace.

Variables locales dans les fonctions

Par défaut, les variables définies dans une fonction sont globales. Si vous oubliez le mot-clé local, vous risquez de remplacer involontairement des variables dans l'environnement appelant.

GLOBAL_COUNT=10

process_data() {
    # ❌ Si 'local' est manquant, GLOBAL_COUNT change globalement
    GLOBAL_COUNT=0 

    # ✅ Manière correcte de définir une variable locale à la fonction
    local TEMP_FILE="/tmp/temp_$(date +%s)"
    echo "Utilisation de $TEMP_FILE"
}

process_data
echo "GLOBAL_COUNT actuel : $GLOBAL_COUNT" # Sortie : 0 (si 'local' était manquant)

Exécution en sous-shell

Un sous-shell est une instance séparée du shell exécutée par le processus parent. Les opérations courantes qui créent un sous-shell comprennent :

Le pipeline (|) :
La substitution de commande ($(...) ou `...`).
Le regroupement par parenthèses (( ... )).

Limitation cruciale : Les variables modifiées ou créées à l'intérieur d'un sous-shell ne peuvent pas être renvoyées au shell parent, sauf si elles sont explicitement écrites dans la sortie standard et capturées.

Exemple de sous-shell (Pipeline)

COUNT=0

# La boucle 'while read' s'exécute dans un sous-shell, en raison du 'grep |' précédent
grep 'pattern' data.txt | while IFS= read -r line; do
    COUNT=$((COUNT + 1)) # La modification se produit dans le sous-shell
done

echo "COUNT final : $COUNT" # Sortie : 0 (Le COUNT du shell parent n'a jamais été mis à jour)

Solution de contournement : Utilisez la substitution de processus (<(...)) ou réécrivez la logique du script pour éviter de tuber vers la boucle while, ou capturez le résultat à l'aide de la substitution de commande.

4. Dépannage des problèmes d'expansion avancée

Certains comportements d'expansion de variables sont spécifiques au type d'expansion utilisé.

Précautions concernant la substitution de commande

La substitution de commande ($(commande)) capture la sortie standard d'une commande. Cette sortie est soumise au fractionnement de mots et au globbing si la substitution n'est pas entre guillemets.

# La sortie de la commande contient des sauts de ligne et des espaces
OUTPUT=$(ls -1 /tmp)

# ❌ Si non citée, la sortie est divisée et traitée comme des arguments individuels
# for ITEM in $OUTPUT; do ...

# ✅ Utiliser un tableau ou une boucle qui traite la sortie ligne par ligne
mapfile -t FILE_LIST < <(ls -1 /tmp)

# Ou assurez-vous que le traitement se produit entre guillemets si vous capturez une seule chaîne de valeur
SAFE_OUTPUT="$(ls -1 /tmp)"

Expansion arithmétique (`$(( ... ))`)

L'expansion arithmétique est utilisée exclusivement pour les calculs entiers. Une erreur courante consiste à essayer d'utiliser des nombres à virgule flottante ou à introduire accidentellement une variable non entière.

# ✅ Arithmétique entière correcte
RESULT=$(( 5 * 10 + VAR_INT ))

# ❌ Bash ne prend pas en charge l'arithmétique en virgule flottante ici
# BAD_RESULT=$(( 10 / 3.5 ))

Pour l'arithmétique en virgule flottante, utilisez des outils externes comme bc ou awk.

5. Débogage des échecs d'expansion de variables

Lorsque des valeurs inattendues ou des chaînes vides apparaissent, utilisez les fonctionnalités de débogage intégrées de Bash.

Tracer l'exécution avec `set -x`

La commande set -x (ou l'exécution du script avec bash -x script.sh) active le traçage de l'exécution. Cela affiche chaque commande après que l'expansion de variables ait eu lieu, vous permettant de voir exactement quels arguments le shell a fournis.

#!/bin/bash
set -x 

FILE_NAME="data report.txt"

# La sortie montre la commande *après* l'expansion :
# + mv data report.txt /archive
mv $FILE_NAME /archive/

# La sortie montre la commande *après* l'expansion correcte :
# + mv 'data report.txt' /archive
mv "$FILE_NAME" /archive/

Imposer des vérifications strictes

Comme mentionné, incluez toujours ces indicateurs de débogage en haut de votre script pour une fiabilité maximale :

set -euo pipefail
# -e : Quitter immédiatement si une commande se termine avec un statut non nul.
# -u : Traiter les variables non définies comme une erreur (nounset).
# -o pipefail : Fait en sorte qu'un pipeline retourne le statut de sortie de la dernière commande qui a échoué (au lieu de la dernière commande du pipeline).

Résumé des meilleures pratiques

Pour prévenir et dépanner efficacement les problèmes d'expansion de variables, respectez ces principes fondamentaux :

Mettre tout entre guillemets : Utilisez des guillemets doubles autour de toutes les expansions de variables ("$VAR") sauf si vous avez spécifiquement l'intention que le fractionnement de mots ou le globbing se produise.
Activer le mode strict : Commencez les scripts critiques par set -euo pipefail.
Localiser les variables : Utilisez le mot-clé local à l'intérieur des fonctions pour éviter la contamination de la portée globale.
Utiliser l'expansion par défaut : Utilisez ${VAR:-default} pour fournir des valeurs de secours gracieuses au lieu de vous fier aux chaînes vides silencieuses.
Comprendre les sous-shells : Reconnaissez que les modifications de variables à l'intérieur des pipes ou de $(...) ne persistent pas dans le shell parent.