diff --git a/351da6e5-004e-4311-ae8b-ebe91a913b3e/draft_overlay.json b/351da6e5-004e-4311-ae8b-ebe91a913b3e/draft_overlay.json deleted file mode 100644 index 68dfa78..0000000 --- a/351da6e5-004e-4311-ae8b-ebe91a913b3e/draft_overlay.json +++ /dev/null @@ -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": "" -} diff --git a/351da6e5-004e-4311-ae8b-ebe91a913b3e/draft_overlay.md b/351da6e5-004e-4311-ae8b-ebe91a913b3e/draft_overlay.md deleted file mode 100644 index f3b706a..0000000 --- a/351da6e5-004e-4311-ae8b-ebe91a913b3e/draft_overlay.md +++ /dev/null @@ -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. \ No newline at end of file diff --git a/351da6e5-004e-4311-ae8b-ebe91a913b3e/index.md b/351da6e5-004e-4311-ae8b-ebe91a913b3e/index.md index 4fbbc0e..f3b706a 100644 --- a/351da6e5-004e-4311-ae8b-ebe91a913b3e/index.md +++ b/351da6e5-004e-4311-ae8b-ebe91a913b3e/index.md @@ -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 - -`&&` 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 : +### Comparaison avec et sans `&&` ```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. \ No newline at end of file +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. \ No newline at end of file diff --git a/351da6e5-004e-4311-ae8b-ebe91a913b3e/meta.json b/351da6e5-004e-4311-ae8b-ebe91a913b3e/meta.json index 4e97e8d..81db1d7 100644 --- a/351da6e5-004e-4311-ae8b-ebe91a913b3e/meta.json +++ b/351da6e5-004e-4311-ae8b-ebe91a913b3e/meta.json @@ -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": "", diff --git a/351da6e5-004e-4311-ae8b-ebe91a913b3e/revisions/0002.md b/351da6e5-004e-4311-ae8b-ebe91a913b3e/revisions/0002.md new file mode 100644 index 0000000..4fbbc0e --- /dev/null +++ b/351da6e5-004e-4311-ae8b-ebe91a913b3e/revisions/0002.md @@ -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. \ No newline at end of file