Structures conditionnelles Bash : tutoriel complet [2026]

Vos structures conditionnelles bash manquent-elles de rigueur, laissant vos scripts exécuter des commandes à l’aveugle même après une erreur critique ? Ce mécanisme logique constitue pourtant l’unique levier pour transformer une série d’instructions fragiles en une automatisation intelligente, capable de prendre des décisions autonomes en temps réel. Nous détaillerons la syntaxe exacte des tests `if`, `else` et `case` pour vous donner les moyens de maîtriser enfin le flux de vos scénarios et de garantir la fiabilité absolue de votre code.

Le B.A.-ba du script bash : la logique if, then et else

La structure de base : if, then, et l’indispensable fi

Pour maîtriser les structures conditionnelles bash, tout repose sur le code de retour d’une commande. Si elle réussit (code zéro), la condition est validée. C’est une logique brute, mais c’est la base du système.

La syntaxe est stricte : if [ condition ]; then ... fi. Le mot-clé then déclenche l’exécution si le test passe. Surtout, n’oubliez jamais fi pour fermer le bloc, sinon le shell renverra une erreur fatale immédiate.

Regardez ce cas simple : if grep "root" /etc/passwd; then echo "Trouvé"; fi.

Le plan B : ajouter un else pour les cas d’échec

Parfois, ça casse. C’est là qu’intervient else. Ce bloc s’active uniquement lorsque la condition initiale échoue, c’est-à-dire quand le code de retour est différent de zéro. C’est votre filet de sécurité.

La structure devient if [ condition ]; then ... else ... fi. Vous gérez ainsi les deux issues possibles : le succès et l’erreur. C’est le minimum pour éviter qu’un script ne plante sans explication.

Reprenons l’exemple : if grep "user" fichier; then ... else echo "Introuvable"; fi.

La commande test et les crochets [ ] : le vrai travail de condition

Le if ne fait qu’évaluer une commande. La plupart du temps, vous utiliserez l’utilitaire test, ou son alias visuel : les crochets [ ].

Voici l’erreur qui piège les débutants : les espaces sont obligatoires. Vous devez écrire if [ "$VAR" -eq 5 ], avec un espace après le crochet ouvrant et avant le fermant. Sans eux, Bash ne comprend rien.

Maîtrisez cette syntaxe et vos conditions fonctionneront enfin du premier coup.

Monter en puissance : gérer des conditions multiples et complexes

Elif : l’alternative propre aux if imbriqués

Oubliez les pyramides de if illisibles qui rendent votre code impossible à maintenir sur le long terme. elif, contraction directe de « else if », reste la méthode standard pour enchaîner proprement les tests sans douleur.

La logique est implacable : si le premier if échoue, Bash évalue immédiatement le elif. Ce processus continue en cascade jusqu’à trouver une correspondance ou tomber sur le else final, qui ramasse tout le reste.

Imaginez un filtre d’âge simple : if [ $age -lt 18 ]... elif [ $age -lt 65 ]... else.... C’est concis et efficace.

Les opérateurs de comparaison à connaître

Attention, piège classique : n’essayez pas d’utiliser les symboles mathématiques < ou > directement dans vos crochets [ ]. Bash exige ses propres opérateurs textuels, sinon votre script plantera lamentablement.

Il faut distinguer deux mondes : les entiers et les chaînes pour maîtriser les structures conditionnelles bash. Voici les correspondances exactes :

• Opérateurs numériques : -eq (égal), -ne (non égal), -gt (supérieur à), -lt (inférieur à), -ge (supérieur ou égal à), -le (inférieur ou égal à).
• Opérateurs pour les chaînes : == (égal), != (différent).

Combiner les tests avec les opérateurs logiques

Pour aller plus loin, les opérateurs && (ET) et || (OU) permettent de construire des scénarios robustes. C’est la clé pour éviter d’écrire dix lignes de code quand une seule suffit.

Le fonctionnement est binaire : && valide l’action uniquement si tout est vrai, alors que || se contente d’une seule réussite. Pour une fiabilité maximale, privilégiez toujours leur usage au sein des doubles crochets [[ ]].

Le choix des armes : [ ], [[ ]] ou (( )) ?

On a vu la logique, mais la syntaxe utilisée pour le test a un impact majeur. C’est souvent sur ce point précis des structures conditionnelles bash que les pros se distinguent.

[ ] : le standard POSIX, fiable mais limité

Les crochets simples [ ] représentent la méthode historique. Son principal avantage est sa compatibilité universelle : il fonctionne sur quasiment tous les systèmes Unix respectant la norme POSIX.

Attention toutefois à ses faiblesses : il est très sensible au « word splitting ». Si une variable contient des espaces, il faut impérativement la mettre entre guillemets ("$VAR") pour éviter des erreurs imprévisibles.

En résumé : c’est l’option sûre pour la portabilité, mais elle demande plus de rigueur.

[[ ]] : la version bash, plus puissante et plus sûre

Les doubles crochets [[ ]] sont une amélioration native propre à Bash. Ce n’est pas une commande, mais un mot-clé du langage, ce qui leur confère bien plus de pouvoir.

Ses avantages sont majeurs : pas de « word splitting » (guillemets moins critiques) et un support natif du « globbing » et des expressions régulières avec l’opérateur =~.

Le conseil est direct : si votre script tourne uniquement avec Bash, privilégiez toujours [[ ]]. C’est plus moderne et moins piégeux.

(( )) : le spécialiste des calculs

Les doubles parenthèses (( )) s’imposent comme l’outil dédié exclusivement aux comparaisons arithmétiques. C’est son unique rôle, conçu pour manipuler les nombres avec une syntaxe naturelle.

Son atout réside dans la lisibilité : à l’intérieur, on utilise les opérateurs de comparaison que tout le monde connaît : ==, !=, >, <. C’est bien plus intuitif que les -eq ou -gt.

Au-delà du if : la structure case et les tests du quotidien

Parfois, une longue chaîne de if/elif est lourde et peu élégante. Bash offre un outil parfait pour ces situations, ainsi que des tests indispensables que vous utiliserez tous les jours.

La structure case : quand une cascade de if ne suffit plus

Oubliez les chaînes interminables de elif testant la même variable. La structure case est l’alternative idéale pour maîtriser les structures conditionnelles bash avec lisibilité et efficacité.

La syntaxe est redoutable : case $VARIABLE in ... esac. Chaque test est un pattern), suivi des commandes, et se termine impérativement par un double point-virgule (;;).

La puissance des patterns est réelle : utilisez des jokers (* pour le défaut) ou des alternatives (oui|yes|o)) pour gérer plusieurs entrées.

Tests sur les fichiers et les chaînes : vos meilleurs alliés

Soyons réalistes : la majorité de vos scripts interagiront avec le système de fichiers ou manipuleront du texte.

Voici les tests de fichiers incontournables pour vérifier vos ressources :

• -e (le fichier ou répertoire existe)
• -f (c’est un fichier)
• -d (c’est un répertoire)
• -r (droit de lecture)
• -w (droit d’écriture)
• -x (droit d’exécution)

Pour éviter les bugs de manipulation de texte, utilisez ces opérateurs vitaux :

• -z « $VAR » (la chaîne est vide)
• -n « $VAR » (la chaîne n’est pas vide). À utiliser avec des guillemets pour plus de sûreté.

Quelques règles d’or pour des scripts solides

Règle n°1 : toujours mettre les variables entre guillemets ("$var") dans les tests, surtout avec [ ]. Sans cela, les espaces ou variables vides feront planter votre script. Ça vous sauvera de nombreux bugs.

Règle n°2 : la lisibilité avant tout. Un code clair est plus simple à maintenir. N’hésitez pas à commenter une condition complexe pour vous ou vos collègues.

Maîtriser les conditions est la clé pour transformer de simples commandes en scripts intelligents et autonomes. Qu’il s’agisse de simples vérifications avec if ou de scénarios complexes via case, la rigueur syntaxique reste votre meilleure alliée. À présent, expérimentez ces structures pour automatiser efficacement vos tâches quotidiennes.