Comprendre les codes de sortie : Gestion efficace des erreurs avec $? et exit

Dans le monde de l'automatisation et du scripting shell, savoir pourquoi un script a échoué est tout aussi important que de savoir qu'il a échoué. Le scripting Bash repose fortement sur un mécanisme standardisé pour signaler le succès ou l'échec : les codes de sortie, également connus sous le nom de statuts de sortie ou codes de retour. Comprendre le fonctionnement de ces codes, comment les inspecter à l'aide de la variable spéciale $?, et comment terminer intentionnellement des scripts à l'aide de la commande exit est fondamental pour écrire des automatisations robustes, fiables et faciles à déboguer.

Ce guide décompose les concepts des codes de sortie, montre comment Bash les suit automatiquement et présente des techniques pratiques pour mettre en œuvre une vérification d'erreurs efficace dans vos scripts shell. Maîtriser cela garantit que vos pipelines d'automatisation échouent avec élégance et fournissent des retours significatifs.

Le concept des statuts de sortie

Chaque commande ou programme exécuté dans un environnement shell de type Unix — qu'il s'agisse d'une commande intégrée comme cd, d'un utilitaire externe comme grep, ou d'un autre script shell — renvoie une valeur entière à la fin de son exécution. Cet entier est le code de sortie, qui signale le résultat de l'opération au processus appelant.

La convention standard

La convention pour les codes de sortie est universellement reconnue :

• 0 (Zéro) : Signifie succès. La commande a été exécutée exactement comme prévu et aucune erreur ne s'est produite.
• 1 à 255 : Signifient échec ou des conditions d'erreur spécifiques. Ces valeurs non nulles indiquent que quelque chose s'est mal passé. Des nombres plus élevés correspondent souvent à des types d'erreurs spécifiques (par exemple, fichier introuvable, autorisation refusée, erreur de syntaxe), bien que la signification exacte dépende du programme spécifique.

Note sur la plage : Bien que les codes de sortie soient techniquement une valeur sur 8 bits (0-255), les scripts shell ne se préoccupent généralement que de 0 pour le succès et de toute valeur non nulle pour l'échec. Les codes de sortie supérieurs à 255 sont généralement tronqués ou interprétés modulo 256 par le shell.

Inspection du dernier code de sortie : La variable $?

La variable shell spéciale $? (dollar point d'interrogation) est essentielle pour surveiller l'état des commandes. Immédiatement après l'exécution de toute commande, le shell stocke son code de sortie dans $?.

Comment utiliser $?

Vous devez vérifier $? immédiatement après la commande qui vous intéresse, car toute commande ultérieure (même l'affichage de la variable) écrasera sa valeur.

Exemple 1 : Vérification du succès et de l'échec

# 1. Une commande réussie
echo "Test de succès" > /dev/null
echo "Code de sortie pour le succès : $?"

# 2. Une commande échouée (ex: essayer de lister un chemin inexistant)
ls /chemin/non/existant
echo "Code de sortie pour l'échec : $?"

Sortie attendue :

Code de sortie pour le succès : 0
ls: impossible d'accéder à '/chemin/non/existant' : Aucun fichier ou dossier de ce type
Code de sortie pour l'échec : 2

Implémentation de la vérification conditionnelle des erreurs

Savoir simplement le code de sortie n'est pas suffisant ; la puissance réside dans l'utilisation de cette information pour contrôler le flux du script. Ceci est généralement réalisé à l'aide d'instructions if ou d'opérateurs de court-circuit (&& et ||).

Utilisation des instructions if

C'est la manière la plus explicite de gérer les erreurs :

if grep -q "données importantes" logfile.txt;
then
    echo "Données trouvées avec succès."
else
    LAST_STATUS=$?
    echo "Erreur : Grep a échoué avec le statut $LAST_STATUS. Données non trouvées."
    # Envisager de quitter ici si le script ne peut pas continuer
fi

Dans l'exemple ci-dessus, grep -q supprime la sortie (-q) et renvoie 0 uniquement si une correspondance est trouvée. La structure if vérifie automatiquement le statut de sortie, mais capturer explicitement $? dans le bloc else est utile pour la journalisation détaillée.

Utilisation de la logique de court-circuit (&& et ||)

Pour des vérifications séquentielles simples, les opérateurs de court-circuit offrent une gestion des erreurs concise :

• && (ET) : La commande suivant && ne s'exécute que si la commande précédente a réussi (retourné 0).
• || (OU) : La commande suivant || ne s'exécute que si la commande précédente a échoué (retourné une valeur non nulle).

Exemple 2 : Gestion concise des erreurs

# 1. Exécuter 'process_data' SEULEMENT SI 'fetch_data' réussit
fetch_data.sh && ./process_data.sh

# 2. Exécuter 'send_alert' UNIQUEMENT SI l'opération principale échoue
rsync -a source/ dest/ || echo "Échec de RSync le $(date)" >> /var/log/rsync_errors.log

Contrôle de la terminaison du script avec exit

La commande exit est utilisée pour terminer immédiatement le script shell ou la fonction en cours et renvoyer un statut de sortie spécifié à l'appelant (qui peut être un autre script ou le terminal de l'utilisateur).

Syntaxe et utilisation

La syntaxe est simplement exit [code_de_statut].

Si aucun statut n'est fourni, exit prend par défaut le statut de la commande au premier plan la plus récemment exécutée. Si vous appelez explicitement exit 0 sans exécuter de commande au préalable, il renvoie 0.

Exemple 3 : Sortie en cas d'échec de pré-condition

Ce script garantit qu'un fichier de configuration requis existe avant de continuer.

CONFIG_FILE="/etc/app/config.conf"

if [[ ! -f "$CONFIG_FILE" ]]; then
    echo "Erreur : Fichier de configuration non trouvé à $CONFIG_FILE."
    # Terminer le script immédiatement avec un code d'erreur spécifique (ex: 20)
    exit 20 
fi

echo "Configuration chargée. Continuation du script..."
# ... reste du script
exit 0

Bonne pratique : Utilisation de codes de sortie significatifs

Bien que 0 et 1 couvrent la plupart des cas de base, l'utilisation de différents codes non nuls aide le script appelant à diagnostiquer le problème exact :

Code	Signification (Exemple)
0	Succès
1	Erreur générale
2-10	Erreurs de syntaxe, problèmes d'analyse des arguments
20	Prérequis manquant (ex: fichier introuvable)
30	Problème de permission

Faire échouer rapidement les scripts : La commande set

Pour une fiabilité maximale dans les scripts complexes, il est fortement recommandé d'activer la vérification des erreurs globalement en utilisant les options de la commande set en haut de votre script :

#!/bin/bash

# Quitter immédiatement si une commande se termine avec un statut non nul.
set -e

# Traiter les variables non définies comme une erreur lors de la substitution.
set -u

# Pipefail : Garantit que le statut de retour d'un pipeline est celui de la dernière commande qui s'est terminée avec un statut non nul.
set -o pipefail

# (Optionnel mais utile) Afficher les commandes au fur et à mesure de leur exécution pour le débogage
# set -x 

# Si une commande ci-dessous échoue, le script s'arrête immédiatement.
ls /chemin/valide && grep motif fichier.txt && ./etape_suivante.sh

# La ligne suivante ne s'exécutera QUE si toutes les commandes précédentes ont réussi.
echo "Toutes les étapes sont terminées."

Lorsque set -e est actif, l'exécution du script s'arrête automatiquement dès le premier statut de sortie non nul, empêchant les commandes suivantes de s'exécuter sur la base de données intermédiaires erronées.