Un if Bash n'évalue pas un booléen : il exécute une commande et regarde son code de retour, où 0 signifie succès donc « vrai ». elif enchaîne des tests alternatifs, évalués dans l'ordre, et else sert de cas par défaut.
Vous trouverez la syntaxe complète, le choix entre [ ], [[ ]] et (( )), les erreurs de quoting avec avant/après, des exemples concrets et une méthode de débogage.
01 / 11
Pourquoi un if Bash teste-t-il un code de retour et non une valeur ?
En Bash, if exécute une commande et considère la condition vraie quand son code de retour vaut 0, faux pour toute autre valeur.
Beaucoup de scripts cassent parce que l'on croit que if évalue une expression, comme dans d'autres langages. Ce n'est pas le cas : Bash exécute une commande et lit son code de retour, aussi appelé statut de sortie. Le succès renvoie 0, donc la condition est vraie. Un échec ou une situation particulière renvoie un nombre de 1 à 255, donc elle est fausse.
Pour le voir, tapez echo $? juste après une commande : la variable spéciale $? contient le code de la dernière commande exécutée. Le crochet [ n'est pas de la syntaxe : c'est une commande, nommée test, qui renvoie 0 ou 1. Voilà pourquoi les espaces comptent autour des crochets. Conséquence pratique : if grep -q motif fichier fonctionne sans aucun crochet, car grep renvoie 0 quand il trouve le motif.
02 / 11
Comment écrire un bloc if, if/else et if/elif/else sans erreur de syntaxe ?
Un bloc Bash s'ouvre par if, enchaîne then après la condition, accepte elif et else en option, et se ferme obligatoirement par fi.
Vous avez un script qui doit réagir selon l'état d'un fichier : Bash propose trois formes. Le simple if couvre une action isolée, if/else gère deux issues, et if/elif/else traite plusieurs cas qui s'excluent.
Le piège courant tient à then : il doit se trouver sur une nouvelle ligne, ou après un point-virgule, comme dans if [ -f "$f" ]; then. Chaque if réclame son propre fi, alors qu'un elif n'en ajoute aucun. Si vous oubliez ce fi, Bash signale « unexpected end of file » à la fin du script.
-
Ouvrir avec if
Écrivez if suivi de la commande ou du test, par exemple if [ -f "$fichier" ].
-
Placer then
Ajoutez ; then sur la même ligne, ou then sur la ligne suivante.
-
Écrire les actions
Indentez les commandes exécutées si la condition est vraie, pour relire facilement.
-
Ajouter elif et else
elif propose un autre test ; else, sans condition, traite tout ce qui reste.
-
Fermer avec fi
Terminez chaque bloc par fi. Comptez vos if et vos fi en fin d'écriture.
Pour la suiteReste à savoir dans quel ordre Bash parcourt vos elif, car cet ordre décide du résultat.
03 / 11
Dans quel ordre Bash évalue-t-il les elif ?
Bash évalue les conditions de haut en bas et exécute uniquement la première branche vraie, puis saute directement au fi.
Prenons un script qui réagit à la taille d'un fichier ou à la valeur d'un code retour : Bash lit vos conditions dans l'ordre et s'arrête à la première qui réussit. Les elif suivants ne sont jamais testés, même s'ils seraient vrais.
Placez donc les cas les plus précis en premier et les plus généraux ensuite, sinon un test large masque tous les autres. Quant à else, il ne tourne que si rien n'a réussi avant lui : réservez-le au cas inattendu et servez-vous-en pour signaler une erreur.
Exemple : classer une valeur n selon des seuils (if n -ge 90, elif n -ge 50, else)
| Valeur de n | Test 1 : n ≥ 90 | Test 2 : n ≥ 50 | Branche exécutée |
|---|---|---|---|
| 95 | vrai | non évalué | if |
| 60 | faux | vrai | elif |
| 10 | faux | faux | else |
| Ordre inversé (≥ 50 en premier), n = 95 | , | vrai | elif : le cas ≥ 90 n'est jamais atteint |
La dernière ligne montre l'anti-pattern : un test large placé trop haut masque le test précis.
04 / 11
Faut-il utiliser [ ], [[ ]] ou (( )) ?
Utilisez [ ] pour un script portable POSIX, [[ ]] pour un script Bash plus sûr et plus riche, et (( )) pour comparer des nombres.
Quand vous écrivez un script, la première question est : sur quelle machine va-t-il tourner ? Si la réponse est « partout », [ ] est la commande test, présente dans tous les shells POSIX. Elle a une contrainte : chaque variable doit être entre guillemets, sinon le test peut se casser dès qu'elle est vide ou contient un espace.
Si vous savez que le script tourne sous Bash, [[ ]] est un mot-clé du langage et non une commande. Il ne découpe donc pas les mots, accepte && et || directement, et propose la correspondance de motifs ou d'expressions régulières avec =~. Le quoting devient moins risqué, ce qui en fait le choix par défaut pour un script Bash.
Pour comparer des nombres, utilisez (( )), qui fait de l'arithmétique : if (( n > 5 )). Les variables n'y demandent pas de $, ce qui rend la lecture plus simple.
05 / 11
Pourquoi une variable non quotée casse-t-elle un test ?
Sans guillemets, Bash remplace la variable par son contenu puis le découpe en mots, ce qui fait disparaître un argument vide ou en ajoute trop à la commande [.
Prenons un script qui compare un nom saisi à « admin ». Si la variable est vide, [ $nom = "admin" ] devient [ = "admin" ] : la commande [ reçoit un opérateur sans valeur à gauche, d'où « unary operator expected ». Si la variable contient « Jean Dupont », Bash la découpe et la commande reçoit quatre mots, d'où « too many arguments ».
La parade tient en une habitude : [ "$nom" = "admin" ]. Les guillemets gardent la valeur en un seul argument, même vide. Dans [[ ]], le découpage n'a pas lieu, mais quoter reste plus prudent. Deux erreurs voisines produisent des bugs tout aussi discrets : oublier l'espace après [ ou avant ], ou écrire [ "$a"="$b" ], qui teste une chaîne non vide et reste toujours vrai.
Pour approfondir
Pour voir précisément ce que Bash fait de votre ligne avant de lancer le test, et comment distinguer une erreur d'un simple résultat négatif.
Comprendre l'erreur
06 / 11
À quoi ressemblent des conditions réelles sur un fichier, une chaîne et un argument ?
Trois cas couvrent l'essentiel des scripts : tester l'existence d'un fichier avec -f, comparer une chaîne avec = ou ==, et vérifier le nombre d'arguments avec -eq ou (( )).
Prenons d'abord un fichier de configuration. Avec if [ -f "$conf" ]; then ... elif [ -d "$conf" ]; then ... else ... fi, votre script distingue un fichier, un dossier et une absence : chaque cas reçoit sa propre réponse, au lieu d'un échec obscur plus loin.
Pour une chaîne, la logique est la même : if [[ "$env" == "prod" ]]; then ... elif [[ "$env" == "test" ]]; then ... else echo "inconnu" >&2; fi. Le else signale sur la sortie d'erreur tout environnement imprévu, donc une faute de frappe ne passe pas inaperçue.
Pour les arguments, if [ $# -ne 1 ]; then echo "Usage : $0 fichier" >&2; exit 1; fi arrête le script dès le départ si l'appel est incorrect.
07 / 11
Quels anti-patterns cassent la logique d'un if, et comment les corriger ?
Cinq anti-patterns reviennent : tester le mauvais opérateur, masquer un cas par l'ordre des elif, oublier else, imbriquer trop et ignorer le code de retour.
Un script qui « marche presque » cache souvent l'un de ces défauts. Le plus fréquent : un mauvais opérateur, par exemple comparer des nombres comme du texte, alors le test ne dit pas ce que vous pensez. Vérifiez ensuite l'ordre des elif. Une condition trop large placée en tête masque les cas suivants, qui ne sont jamais atteints.
Sans else, un cas imprévu passe sans bruit. Trop d'imbrications rendent la lecture pénible, donc découpez ou sortez tôt. Enfin, ignorer le code de retour d'une commande revient à supposer qu'elle a réussi. Relisez votre script avec cette liste et corrigez-les un par un.
Comparer des nombres avec = ou >
Dans [ ], = compare du texte et > redirige vers un fichier ! Utilisez -eq, -lt, -gt, ou (( )).
Un test large placé avant un test précis
Le premier vrai gagne : remontez le cas précis, descendez le cas général.
Else absent
Sans else, un cas imprévu passe en silence. Ajoutez un message d'erreur et un exit non nul.
Imbrication profonde
Utilisez des clauses de garde avec exit ou return, ou un case pour plusieurs valeurs d'une même variable.
Code de retour ignoré
if commande ; then est plus fiable que lancer commande puis tester $? plus loin, car $? change à chaque commande.
08 / 11
Comment déboguer un if qui ne se déclenche pas ?
Pour comprendre pourquoi une branche ne s'exécute pas, activez set -x, affichez les valeurs et les codes de retour, puis passez le script dans ShellCheck.
Quand une branche ne s'exécute jamais, cessez de relire le script en boucle et suivez un ordre précis. D'abord la trace, ensuite les valeurs, puis le code de retour, enfin l'analyse statique. Chaque étape élimine une famille d'erreurs.
Lancez bash -x script.sh, ou placez set -x avant le bloc douteux. Bash affiche alors chaque commande après développement. Vous voyez ainsi la ligne réellement testée, avec les variables déjà remplacées. Si une variable est vide ou contient un espace inattendu, cela saute aux yeux. set +x arrête la trace. Affichez ensuite les valeurs avec echo, puis le code de retour de la commande testée. C'est lui que if évalue.
Passez enfin le script dans ShellCheck. Il signale, avant l'exécution, les variables non quotées, les opérateurs mal utilisés et les if mal formés.
Pour approfondir
Savoir lire la trace de set -x permet de trouver en quelques minutes un défaut invisible, comme un caractère caché dans une valeur.
Lire la trace
09 / 11
Quelle syntaxe de condition adopter dans vos scripts ?
Choisissez un shebang clair (#!/bin/bash ou #!/bin/sh), quotez systématiquement, structurez vos elif du plus précis au plus général et vérifiez avec ShellCheck.
Si votre script ne tourne que sous Bash, adoptez [[ ]] pour les tests et (( )) pour l'arithmétique : ils sont plus sûrs et plus lisibles. Comme le script doit aussi tourner ailleurs, restez sur [ ] et testez-le avec dash, où les écarts de syntaxe se manifestent en premier.
Vous pouvez ajouter set -euo pipefail, à condition d'y aller prudemment. Il durcit le comportement du script et change la façon dont les tests échouent, si bien qu'une condition qui passait jusque-là peut désormais arrêter l'exécution. Pour un script critique, faites relire les conditions par un collègue et gardez quelques cas de test : une valeur vide, une valeur avec des espaces, un fichier absent. Ma priorité consiste à corriger le shebang et le quotage, puis à lancer ShellCheck sur votre script le plus utilisé.
10 / 11
Comment écrire des conditions Bash dont vous pouvez vous fier ?
Une condition Bash fiable repose sur trois réflexes : comprendre que if teste un code de retour, choisir la bonne syntaxe de test et quoter vos variables.
Tout repose sur un principe simple. if exécute une commande et ne regarde que son code de retour. Une fois cela acquis, le reste s'enchaîne. Le bloc if, elif, else se ferme par fi, Bash lit les branches de haut en bas et n'en exécute qu'une. Placez donc vos cas du plus précis au plus général, sinon un elif trop large masquera les suivants.
Côté syntaxe, le choix dépend de la cible : [ ] pour la portabilité POSIX, [[ ]] et (( )) si le script reste sous Bash. Quelle que soit la syntaxe, quotez systématiquement vos variables. Une valeur vide ou contenant des espaces suffit à casser un test. Quand une branche ne se déclenche pas, set -x, l'affichage des valeurs et ShellCheck vous montrent vite pourquoi. Pour un script critique, une relecture par un collègue et quelques cas de test (valeur vide, espaces, fichier absent) sécurisent l'ensemble. Ajoutez set -euo pipefail avec précaution, puisqu'il modifie la façon dont les tests échouent.
11 / 11






