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

.. contents::
   :depth: 2
   :local:
   :backlinks: top

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
----------------------------------

.. list-table::
   :header-rows: 1
   :widths: 20 30 50

   * - 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**

.. code-block:: bash

   #!/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**

.. code-block:: bash

   #!/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`**

.. code-block:: bash

   #!/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** :

1. Chaque argument positionnel est assigné à son prédécesseur : `$2` devient `$1`, `$3` devient `$2`, etc.
2. 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`**

.. code-block:: bash

   #!/bin/bash
   set -x

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

**Exécution** :

.. code-block:: bash

   ./script.sh arg1 arg2 arg3

**Résultat** :

.. code-block::

   + [[ 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`**

.. code-block:: bash

   #!/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** :

.. code-block:: bash

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

**Résultat avec `shift 2`** :

.. code-block::

   + [[ 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**

.. code-block:: bash

   #!/bin/bash
   set -x

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

**Exemple 2 : Exécution conditionnelle** :

.. code-block:: bash

   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**

.. code-block:: bash

   #!/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)**

.. code-block:: bash

   #!/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`**

.. code-block:: bash

   #!/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**

.. code-block:: bash

   #!/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