publish: L'opérateur && — exécution conditionnelle

2026-05-16 18:05:59 +02:00
parent e7c6962909
commit cf38fa8f73
5 changed files with 204 additions and 213 deletions
@@ -1,15 +0,0 @@
 {
    "title": "L'opérateur `&&` — exécution conditionnelle",
    "_updated_at": "2026-05-16 16:05:57",
    "slug": "symbole-double-et-commercial",
    "published": true,
    "published_at": "2023-02-18 16:25",
    "category": "Informatique",
    "tags": {
        "tags": [
            "Bash"
        ]
    },
    "seo_title": "",
    "seo_description": ""
 }
@@ -1,183 +0,0 @@
 # L'opérateur `&&` — exécution conditionnelle
 L'opérateur `&&` permet d'enchaîner deux commandes en exécutant la seconde **uniquement si la première a réussi**. C'est un opérateur logique « ET » qui s'appuie sur le **code de retour** (*exit status*) des commandes.
 ## Rappel : le code de retour
 Chaque commande Unix renvoie un code de retour en fin d'exécution :
 - **`0`** = succès
 - **toute autre valeur (1 à 255)** = échec (le chiffre précise souvent le type d'erreur)
 On peut consulter ce code avec la variable spéciale `$?` :
 ```bash
 ~ $ ls /tmp
 fichier1.txt  fichier2.txt
 ~ $ echo $?
 0                            # ✅ succès
 ~ $ ls /dossier_inexistant
 ls: impossible d'accéder à '/dossier_inexistant': Aucun fichier ou dossier de ce type
 ~ $ echo $?
 2                            # ❌ échec
 ```
 C'est ce code que `&&` examine pour décider s'il exécute ou non la commande suivante.
 ## Syntaxe et fonctionnement
 ```bash
 commande1 && commande2
 ```
 - Si `commande1` réussit (code `0`) → `commande2` est exécutée.
 - Si `commande1` échoue (code ≠ `0`) → `commande2` est **ignorée**.
 ### Exemple basique
 ```bash
 ~ $ mkdir mon_projet && cd mon_projet
 ~/mon_projet $
 ```
 Ici, on entre dans le dossier `mon_projet` **uniquement** s'il a été créé avec succès. Si `mkdir` échoue (par exemple parce que le dossier existe déjà), le `cd` n'est pas tenté — ce qui évite de se retrouver dans un état imprévu.
 ### Comparaison avec et sans `&&`
 ```bash
 # ❌ Sans &&, les deux commandes s'exécutent quoi qu'il arrive
 ~ $ mkdir mon_projet ; cd mon_projet
 mkdir: impossible de créer le répertoire « mon_projet »: Le fichier existe
 ~/mon_projet $        # cd a quand même été exécuté
 # ✅ Avec &&, cd n'est pas exécuté si mkdir échoue
 ~ $ mkdir mon_projet && cd mon_projet
 mkdir: impossible de créer le répertoire « mon_projet »: Le fichier existe
 ~ $                   # on est resté dans le dossier d'origine
 ```
 Le point-virgule `;` enchaîne sans condition, alors que `&&` enchaîne **sous condition de succès**.
 ## Cas d'usage courants
 ### 1. Compiler puis exécuter un programme
 ```bash
 ~ $ gcc -o monprog monprog.c && ./monprog
 ```
 Le programme n'est lancé que si la compilation a réussi. Si `gcc` échoue, on évite d'exécuter une version obsolète ou inexistante.
 ### 2. Mettre à jour puis installer un paquet
 ```bash
 ~ $ sudo apt update && sudo apt install nginx
 ```
 L'installation n'est tentée que si la mise à jour de la liste des paquets s'est bien passée. Cela évite d'installer une version périmée si les dépôts sont temporairement inaccessibles.
 ### 3. Vérifier l'existence d'un fichier avant de l'utiliser
 ```bash
 ~ $ test -f config.txt && source config.txt
 ```
 Le fichier `config.txt` n'est chargé que s'il existe vraiment. Sinon, on évite une erreur bruyante.
 ### 4. Sauvegarder avant de modifier
 ```bash
 ~ $ cp important.txt important.txt.bak && nano important.txt
 ```
 L'édition n'est lancée qu'après la sauvegarde réussie de l'original.
 ## Chaîner plusieurs `&&`
 On peut enchaîner autant de `&&` que nécessaire. L'exécution s'arrête **dès qu'une commande échoue** :
 ```bash
 ~ $ cd /tmp && mkdir test && cd test && touch fichier.txt && ls
 fichier.txt
 ```
 Si l'une de ces étapes échoue, toutes les suivantes sont sautées. C'est particulièrement utile dans les scripts de déploiement :
 ```bash
 #!/bin/bash
 git pull \
  && npm install \
  && npm run build \
  && npm test \
  && npm run deploy
 ```
 Le déploiement n'a lieu que si toutes les étapes précédentes (récupération du code, installation, build, tests) ont réussi. Au moindre échec, la chaîne s'interrompt.
 ## L'opérateur complémentaire `||`
 Pour bien comprendre `&&`, il faut le mettre en parallèle avec `||` (« OU »), qui fait l'inverse : il exécute la seconde commande **uniquement si la première a échoué**.
 ```bash
 ~ $ ls /dossier_inexistant || echo "Le dossier n'existe pas !"
 ls: impossible d'accéder à '/dossier_inexistant': Aucun fichier ou dossier de ce type
 Le dossier n'existe pas !
 ```
 ### Combinaison `&&` et `||` : un « if/else » en une ligne
 On peut combiner les deux pour exprimer un test conditionnel concis :
 ```bash
 ~ $ test -f config.txt && echo "Fichier trouvé" || echo "Fichier absent"
 ```
 - Si `config.txt` existe → affiche « Fichier trouvé ».
 - Sinon → affiche « Fichier absent ».
 ⚠️ **Attention à un piège** : si la commande après `&&` échoue elle-même, la branche `||` sera quand même exécutée. Exemple :
 ```bash
 ~ $ test -f config.txt && echo "trouvé" > /fichier/interdit || echo "absent"
 absent       # 🤔 alors que config.txt existait bien !
 ```
 Ici, `test -f` a réussi, mais l'écriture dans `/fichier/interdit` a échoué — donc `||` s'est déclenché à tort. Pour un vrai if/else sans ce risque, mieux vaut utiliser la structure complète :
 ```bash
 if test -f config.txt; then
    echo "trouvé"
 else
    echo "absent"
 fi
 ```
 ## Vérifier soi-même le comportement
 Petit test pour bien visualiser le mécanisme :
 ```bash
 ~ $ true && echo "ça passe"
 ça passe
 ~ $ false && echo "ça passe"
                              # rien ne s'affiche
 ~ $ true || echo "ça passe"
                              # rien ne s'affiche
 ~ $ false || echo "ça passe"
 ça passe
 ```
 `true` est une commande qui réussit toujours (code `0`) et `false` une commande qui échoue toujours (code `1`) — idéales pour comprendre les opérateurs logiques.
 ## À retenir
 | Opérateur | Signification | Exécute la 2ᵉ commande si...        |
 |-----------|---------------|--------------------------------------|
 | `;`       | Enchaînement  | ...toujours (peu importe le résultat)|
 | `&&`      | ET logique    | ...la 1ʳᵉ a **réussi** (code `0`)    |
 | `\|\|`    | OU logique    | ...la 1ʳᵉ a **échoué** (code ≠ `0`)  |
 `&&` est l'un des outils les plus utilisés en scripting shell : il rend le code à la fois plus court et plus sûr, en empêchant les commandes de s'exécuter dans un contexte d'erreur.
@@ -1,31 +1,183 @@
-# L'opérateur `&&` en Bash
+# L'opérateur `&&` — exécution conditionnelle
-Dans un shell Unix comme Bash, `&&` est un opérateur logique **ET** qui sert à enchaîner des commandes de manière conditionnelle : la commande de droite ne s'exécute que si celle de gauche a réussi.
+L'opérateur `&&` permet d'enchaîner deux commandes en exécutant la seconde **uniquement si la première a réussi**. C'est un opérateur logique « ET » qui s'appuie sur le **code de retour** (*exit status*) des commandes.
-## Fonctionnement
+## Rappel : le code de retour
-Considérons la syntaxe suivante :
+Chaque commande Unix renvoie un code de retour en fin d'exécution :
 - **`0`** = succès
 - **toute autre valeur (1 à 255)** = échec (le chiffre précise souvent le type d'erreur)
 On peut consulter ce code avec la variable spéciale `$?` :
 ```bash
 ~ $ ls /tmp
 fichier1.txt  fichier2.txt
 ~ $ echo $?
 0                            # ✅ succès
 ~ $ ls /dossier_inexistant
 ls: impossible d'accéder à '/dossier_inexistant': Aucun fichier ou dossier de ce type
 ~ $ echo $?
 2                            # ❌ échec
 ```
 C'est ce code que `&&` examine pour décider s'il exécute ou non la commande suivante.
 ## Syntaxe et fonctionnement
 ```bash
 commande1 && commande2
 ```
-`commande2` ne sera exécutée que si `commande1` se termine avec un code de retour égal à `0` (le code conventionnel de succès sous Unix). Si `commande1` échoue, `commande2` est ignorée.
+- Si `commande1` réussit (code `0`) → `commande2` est exécutée.
 - Si `commande1` échoue (code ≠ `0`) → `commande2` est **ignorée**.
-## Un exemple concret
+### Exemple basique
 ```bash
-mkdir mon_projet && cd mon_projet
+~ $ mkdir mon_projet && cd mon_projet
 ~/mon_projet $
 ```
-Ici, on entre dans le dossier `mon_projet` uniquement s'il a bien été créé. Cela évite, par exemple, de se retrouver à travailler dans le mauvais répertoire si la création échoue.
+Ici, on entre dans le dossier `mon_projet` **uniquement** s'il a été créé avec succès. Si `mkdir` échoue (par exemple parce que le dossier existe déjà), le `cd` n'est pas tenté — ce qui évite de se retrouver dans un état imprévu.
-## Pour aller plus loin
+### Comparaison avec et sans `&&`
 `&&` a un complément naturel : l'opérateur `||` (**OU logique**), qui exécute la commande de droite uniquement si celle de gauche échoue. On les combine souvent pour gérer succès et erreurs sur une seule ligne :
 ```bash
-commande1 && echo "Succès" || echo "Échec"
+# ❌ Sans &&, les deux commandes s'exécutent quoi qu'il arrive
 ~ $ mkdir mon_projet ; cd mon_projet
 mkdir: impossible de créer le répertoire « mon_projet »: Le fichier existe
 ~/mon_projet $        # cd a quand même été exécuté
 # ✅ Avec &&, cd n'est pas exécuté si mkdir échoue
 ~ $ mkdir mon_projet && cd mon_projet
 mkdir: impossible de créer le répertoire « mon_projet »: Le fichier existe
 ~ $                   # on est resté dans le dossier d'origine
 ```
-Ces opérateurs sont particulièrement utiles dans les scripts shell et les pipelines CI/CD, où enchaîner des étapes dépendantes du résultat précédent est un besoin courant.
+Le point-virgule `;` enchaîne sans condition, alors que `&&` enchaîne **sous condition de succès**.
 ## Cas d'usage courants
 ### 1. Compiler puis exécuter un programme
 ```bash
 ~ $ gcc -o monprog monprog.c && ./monprog
 ```
 Le programme n'est lancé que si la compilation a réussi. Si `gcc` échoue, on évite d'exécuter une version obsolète ou inexistante.
 ### 2. Mettre à jour puis installer un paquet
 ```bash
 ~ $ sudo apt update && sudo apt install nginx
 ```
 L'installation n'est tentée que si la mise à jour de la liste des paquets s'est bien passée. Cela évite d'installer une version périmée si les dépôts sont temporairement inaccessibles.
 ### 3. Vérifier l'existence d'un fichier avant de l'utiliser
 ```bash
 ~ $ test -f config.txt && source config.txt
 ```
 Le fichier `config.txt` n'est chargé que s'il existe vraiment. Sinon, on évite une erreur bruyante.
 ### 4. Sauvegarder avant de modifier
 ```bash
 ~ $ cp important.txt important.txt.bak && nano important.txt
 ```
 L'édition n'est lancée qu'après la sauvegarde réussie de l'original.
 ## Chaîner plusieurs `&&`
 On peut enchaîner autant de `&&` que nécessaire. L'exécution s'arrête **dès qu'une commande échoue** :
 ```bash
 ~ $ cd /tmp && mkdir test && cd test && touch fichier.txt && ls
 fichier.txt
 ```
 Si l'une de ces étapes échoue, toutes les suivantes sont sautées. C'est particulièrement utile dans les scripts de déploiement :
 ```bash
 #!/bin/bash
 git pull \
  && npm install \
  && npm run build \
  && npm test \
  && npm run deploy
 ```
 Le déploiement n'a lieu que si toutes les étapes précédentes (récupération du code, installation, build, tests) ont réussi. Au moindre échec, la chaîne s'interrompt.
 ## L'opérateur complémentaire `||`
 Pour bien comprendre `&&`, il faut le mettre en parallèle avec `||` (« OU »), qui fait l'inverse : il exécute la seconde commande **uniquement si la première a échoué**.
 ```bash
 ~ $ ls /dossier_inexistant || echo "Le dossier n'existe pas !"
 ls: impossible d'accéder à '/dossier_inexistant': Aucun fichier ou dossier de ce type
 Le dossier n'existe pas !
 ```
 ### Combinaison `&&` et `||` : un « if/else » en une ligne
 On peut combiner les deux pour exprimer un test conditionnel concis :
 ```bash
 ~ $ test -f config.txt && echo "Fichier trouvé" || echo "Fichier absent"
 ```
 - Si `config.txt` existe → affiche « Fichier trouvé ».
 - Sinon → affiche « Fichier absent ».
 ⚠️ **Attention à un piège** : si la commande après `&&` échoue elle-même, la branche `||` sera quand même exécutée. Exemple :
 ```bash
 ~ $ test -f config.txt && echo "trouvé" > /fichier/interdit || echo "absent"
 absent       # 🤔 alors que config.txt existait bien !
 ```
 Ici, `test -f` a réussi, mais l'écriture dans `/fichier/interdit` a échoué — donc `||` s'est déclenché à tort. Pour un vrai if/else sans ce risque, mieux vaut utiliser la structure complète :
 ```bash
 if test -f config.txt; then
    echo "trouvé"
 else
    echo "absent"
 fi
 ```
 ## Vérifier soi-même le comportement
 Petit test pour bien visualiser le mécanisme :
 ```bash
 ~ $ true && echo "ça passe"
 ça passe
 ~ $ false && echo "ça passe"
                              # rien ne s'affiche
 ~ $ true || echo "ça passe"
                              # rien ne s'affiche
 ~ $ false || echo "ça passe"
 ça passe
 ```
 `true` est une commande qui réussit toujours (code `0`) et `false` une commande qui échoue toujours (code `1`) — idéales pour comprendre les opérateurs logiques.
 ## À retenir
 | Opérateur | Signification | Exécute la 2ᵉ commande si...        |
 |-----------|---------------|--------------------------------------|
 | `;`       | Enchaînement  | ...toujours (peu importe le résultat)|
 | `&&`      | ET logique    | ...la 1ʳᵉ a **réussi** (code `0`)    |
 | `\|\|`    | OU logique    | ...la 1ʳᵉ a **échoué** (code ≠ `0`)  |
 `&&` est l'un des outils les plus utilisés en scripting shell : il rend le code à la fois plus court et plus sûr, en empêchant les commandes de s'exécuter dans un contexte d'erreur.
@@ -1,19 +1,25 @@
 {
    "uuid": "351da6e5-004e-4311-ae8b-ebe91a913b3e",
    "slug": "symbole-double-et-commercial",
-    "title": "L'opérateur `&&` en Bash",
+    "title": "L'opérateur `&&` — exécution conditionnelle",
    "author": "cedric@abonnel.fr",
    "published": true,
    "featured": false,
    "published_at": "2023-02-18 16:25",
    "created_at": "2023-02-18 16:25:42",
-    "updated_at": "2026-05-16 16:02:41",
+    "updated_at": "2026-05-16 16:05:59",
    "revisions": [
        {
            "n": 1,
            "date": "2026-05-16 16:02:41",
            "comment": "Titre modifié, tags modifiés, contenu modifié",
            "title": "&&"
        },
        {
            "n": 2,
            "date": "2026-05-16 16:05:59",
            "comment": "Titre modifié, contenu modifié",
            "title": "L'opérateur `&&` en Bash"
        }
    ],
    "cover": "",
@@ -0,0 +1,31 @@
 # L'opérateur `&&` en Bash
 Dans un shell Unix comme Bash, `&&` est un opérateur logique **ET** qui sert à enchaîner des commandes de manière conditionnelle : la commande de droite ne s'exécute que si celle de gauche a réussi.
 ## Fonctionnement
 Considérons la syntaxe suivante :
 ```bash
 commande1 && commande2
 ```
 `commande2` ne sera exécutée que si `commande1` se termine avec un code de retour égal à `0` (le code conventionnel de succès sous Unix). Si `commande1` échoue, `commande2` est ignorée.
 ## Un exemple concret
 ```bash
 mkdir mon_projet && cd mon_projet
 ```
 Ici, on entre dans le dossier `mon_projet` uniquement s'il a bien été créé. Cela évite, par exemple, de se retrouver à travailler dans le mauvais répertoire si la création échoue.
 ## Pour aller plus loin
 `&&` a un complément naturel : l'opérateur `||` (**OU logique**), qui exécute la commande de droite uniquement si celle de gauche échoue. On les combine souvent pour gérer succès et erreurs sur une seule ligne :
 ```bash
 commande1 && echo "Succès" || echo "Échec"
 ```
 Ces opérateurs sont particulièrement utiles dans les scripts shell et les pipelines CI/CD, où enchaîner des étapes dépendantes du résultat précédent est un besoin courant.