Commandes Bash : Built-in, controle de flux et de signaux

Introduction 

Cette documentation présente des commandes Bash essentielles : exit, break, set, shift, eval, local, trap, et return. Ces commandes permettent de gérer le flux d’exécution, de sécuriser les scripts, et d’améliorer leur lisibilité et maintenabilité.

Chaque commande est accompagnée d’exemples pratiques, de résultats débogués et d’analyses approfondies pour aider à comprendre leur fonctionnement.

Résumé des Commandes et Catégories 

Commande	Catégorie	Description
set	Commande intégrée / Built-in	Configure le comportement du shell.
return	Commande Built-in / Contrôle de flux	Termine une fonction avec un code de retour.
exit	Commande Built-in	Termine un script ou le shell avec un code de retour.
trap	Commande Built-in / Gestion des signaux	Définit des actions pour des signaux spécifiques.
break	Commande de contrôle de flux	Interrompt une boucle immédiatement.
shift	Commande Built-in / Gestion de l’environnement	Décale les arguments positionnels pour les manipuler dynamiquement.

—

Les commandes:

Exit 

La commande exit termine immédiatement un script ou une fonction en renvoyant un code de retour.

Cas d’utilisation :

Signaler un état final du script avec un code de retour.
Interrompre un script ou une fonction en cas d’erreur critique.

Codes de retour standards :

0 : Succès.
1 : Erreur générale.
Autres valeurs (2, 3, etc.) : Indiquent des erreurs spécifiques définies par le script.

Exemple : Terminer un script avec des codes de retour

#!/bin/bash
set -x

echo "Début du script."

if [[ -z "$1" ]]; then
    echo "Erreur : Argument manquant."
    exit 1
fi

echo "Argument fourni : $1"
exit 0

Différence entre `exit` et `return` :

exit termine l’exécution du script entier.
return quitte une fonction, mais permet au script principal de continuer.

—

Break 

La commande break interrompt immédiatement une boucle for, while ou until.

Code de retour :

break n’émet pas de code de retour, il interrompt simplement la boucle. Si une commande échoue avant le break, le code de retour de cette commande est disponible dans $?.

Exemple : Arrêter une boucle sur une condition

#!/bin/bash
set -x

for i in {1..10}; do
    if [[ $i -eq 5 ]]; then
        echo "Interruption à $i"
        break
    fi
    echo "Itération $i"
done

Analyse :

La boucle s’arrête dès que i atteint 5.
Les itérations suivantes ne sont pas exécutées grâce à break.

—

Set 

La commande set configure des options de comportement du shell. Elle permet d’améliorer la robustesse et la sécurité des scripts.

Options courantes :

-e : Arrête le script en cas d’erreur.
-u : Signale une erreur si une variable non initialisée est utilisée.
-o pipefail : Propagation des erreurs dans les pipelines.
-x : Affiche chaque commande exécutée pour le débogage.

Exemple : Sécuriser un script avec `set`

#!/bin/bash
set -euo pipefail

echo "Début du script."

if [[ -z "${1:-}" ]]; then
    echo "Erreur : Aucun argument fourni."
    exit 1
fi

ls "$1"

echo "Fin du script."

Avantage :

Avec set -euo pipefail, le script est arrêté immédiatement si une erreur survient.

—

Shift 

La commande shift décale les arguments positionnels vers la gauche, supprimant le premier ($1) à chaque appel. Cela permet de parcourir et de traiter un nombre variable d’arguments.

Comment cela fonctionne :

Chaque argument positionnel est assigné à son prédécesseur : $2 devient $1, $3 devient $2, etc.
Le dernier argument est supprimé de la liste des arguments disponibles ($# diminue).

Cas d’utilisation :

Gérer des options en ligne de commande.
Traiter dynamiquement des arguments multiples.

Exemple 1 : Traitement des arguments avec `shift`

#!/bin/bash
set -x

while [[ $# -gt 0 ]]; do
    echo "Argument : $1"
    shift
done

Exécution :

./script.sh arg1 arg2 arg3

Résultat :

+ [[ 3 -gt 0 ]]
+ echo 'Argument : arg1'
Argument : arg1
+ shift
+ [[ 2 -gt 0 ]]
+ echo 'Argument : arg2'
Argument : arg2
+ shift
+ [[ 1 -gt 0 ]]
+ echo 'Argument : arg3'
Argument : arg3
+ shift

Exemple 2 : Traitement d’options et valeurs avec `shift 2`

#!/bin/bash
set -x

while [[ $# -gt 0 ]]; do
    case "$1" in
        -o|--output)
            output_file="$2"
            echo "Fichier de sortie défini : $output_file"
            shift 2
            ;;
        -v|--verbose)
            echo "Mode verbeux activé"
            shift
            ;;
        *)
            echo "Option inconnue : $1"
            shift
            ;;
    esac
done

Exécution :

./script.sh -o result.txt -v --unknown-option

Résultat avec `shift 2` :

+ [[ 4 -gt 0 ]]
+ case "$1" in
+ output_file=result.txt
+ echo 'Fichier de sortie défini : result.txt'
Fichier de sortie défini : result.txt
+ shift 2
+ [[ 2 -gt 0 ]]
+ case "$1" in
+ echo 'Mode verbeux activé'
Mode verbeux activé
+ shift
+ [[ 1 -gt 0 ]]
+ case "$1" in
+ echo 'Option inconnue : --unknown-option'
Option inconnue : --unknown-option
+ shift
+ [[ 0 -gt 0 ]]

—

Eval 

La commande eval évalue et exécute dynamiquement une commande ou une expression.

Avantages :

Permet de construire des commandes complexes à partir de variables.
Utile pour traiter des entrées dynamiques.

Exemple 1 : Exécution dynamique

#!/bin/bash
set -x

command="ls"
options="-l /tmp"
eval "$command $options"

Exemple 2 : Exécution conditionnelle :

eval "echo \$HOME"

Résultat : Affiche le répertoire personnel de l’utilisateur.

Attention : eval peut être dangereux s’il est utilisé avec des données non fiables.

—

Local 

La commande local limite la portée d’une variable à l’intérieur d’une fonction, évitant de polluer l’espace global.

Exemple : Variable locale

#!/bin/bash
set -x

my_function() {
    local var="locale"
    echo "Variable locale : $var"
}

my_function
echo "Variable globale : ${var:-vide}"

Analyse : - La variable var est accessible uniquement dans la fonction.

—

Trap 

La commande trap exécute une commande ou une fonction spécifiée lorsqu’un signal est reçu.

Signaux courants :

SIGINT : Envoyé par Ctrl+C.
EXIT : Signal émis à la fin du script.

Exemple 1 : Gestion de `SIGINT` (Ctrl+C)

#!/bin/bash
set -x

trap 'echo "Interruption détectée !"; exit 1' SIGINT

while true; do
    echo "Travail en cours..."
    sleep 1
done

Exemple 2 : Nettoyage avec `EXIT`

#!/bin/bash
set -x

cleanup() {
    echo "Nettoyage des ressources..."
}

trap cleanup EXIT

echo "Début du script."
sleep 5
echo "Fin du script."

—

Return 

La commande return termine une fonction et retourne un code de retour.

Différence avec `exit` :

return quitte une fonction sans arrêter le script principal.
exit termine l’exécution du script entier.

Exemple : Retourner un état

#!/bin/bash
set -x

my_function() {
    if [[ -z "$1" ]]; then
        echo "Erreur : Argument manquant."
        return 1
    fi
    echo "Argument : $1"
    return 0
}

my_function "test"
echo "Code de retour : $?"

Analyse :

Si l’argument est manquant, la fonction retourne 1, mais le script principal continue.

—

Meta 

Auteur : Cbillet
Date : 07/12/2024