Déclarer et utiliser des booléens dans Bash

Bash ne possède pas de type dédié pour les variables booléennes. Pour représenter un choix, vous pouvez utiliser directement le statut de réussite ou d’échec d’une commande, ou adopter une convention de valeurs, par exemple 1 pour activé et 0 pour désactivé. Il s’agit de deux notions différentes : le statut 0 d’une commande indique une réussite, tandis qu’une valeur non nulle indique un échec. Les exemples ci-dessous montrent comment utiliser ces deux formes sans exécuter comme des commandes le contenu arbitraire de variables.

Valeurs booléennes et statut de sortie dans Bash

Les commandes true et false indiquent respectivement une réussite et un échec. Une instruction if évalue leur statut : ce sont des commandes, et non des valeurs spéciales stockées dans des variables. Un script peut aussi utiliser un indicateur entier documenté lorsqu’une valeur doit être stockée ou transmise comme argument.

Utiliser true et false dans des conditions

Utilisez directement une commande comme condition lorsque vous voulez savoir si elle a réussi ou échoué. Bash peut ainsi choisir une branche en fonction du statut de sortie de la commande.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

if true; then
    printf '%s\n' 'The command succeeded.'
fi

if false; then
    printf '%s\n' 'This branch is skipped.'
else
    printf '%s\n' 'The command reported failure.'
fi

Évitez d’écrire if $value; then pour tester une variable. Bash tenterait d’exécuter le contenu de cette variable comme une commande. Comparez plutôt une valeur connue ou utilisez une expression de test.

Représenter un état de type booléen dans des variables

Un indicateur entier relève d’une convention propre à l’application : choisissez sa correspondance et documentez-la. Cet exemple utilise 1 pour activé et 0 pour désactivé. Les conditions arithmétiques le comparent numériquement, sans le confondre avec le statut d’une commande.

Exécutez cet exemple Bash pour voir l’indicateur activé testé numériquement, transmis à une fonction et utilisé pour contrôler la sortie d’une boucle.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

enabled=1

if (( enabled == 1 )); then
    printf '%s\n' 'Feature is enabled.'
else
    printf '%s\n' 'Feature is disabled.'
fi

report_feature() {
    local flag=$1
    if (( flag == 1 )); then
        printf '%s\n' 'Function received an enabled flag.'
    else
        printf '%s\n' 'Function received a disabled flag.'
    fi
}

report_feature "$enabled"

for item in alpha beta; do
    if (( enabled == 1 )); then
        printf 'Processing %s.\n' "$item"
    fi
done

Feature is enabled.
Function received an enabled flag.
Processing alpha.
Processing beta.

Pour vérifier des fichiers, privilégiez l’expression de test appropriée. Dans les tests avec [, mettez les expansions entre guillemets afin qu’une valeur absente ou contenant des espaces ne modifie pas les arguments du test. Pour les conditions propres à Bash, utilisez [[ ... ]] ou la syntaxe arithmétique.

Combiner des conditions avec des opérateurs logiques

&& exécute la commande située à droite uniquement si celle de gauche réussit. || exécute la commande de droite si celle de gauche échoue. Ces deux opérateurs s’appuient donc sur le statut des commandes : zéro indique une réussite. Si le regroupement voulu risque d’être difficile à lire, ajoutez des parenthèses ou utilisez plusieurs instructions if.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

is_logged_in=1
is_admin=0

if (( is_logged_in == 1 && is_admin == 1 )); then
    printf '%s\n' 'Access granted.'
else
    printf '%s\n' 'Access denied.'
fi

config_file=/etc/example.conf
if [[ -f "$config_file" ]] && printf '%s\n' 'Configuration file exists.'; then
    :
fi

La première condition combine deux indicateurs entiers. La seconde vérifie l’existence d’un fichier avant d’afficher son message ; [[ -f ... ]] est une expression conditionnelle de Bash, et non une commande qui produit une variable booléenne.

Utiliser des indicateurs dans des fonctions et des boucles

Transmettez un indicateur explicitement défini comme argument de fonction entre guillemets, puis comparez-le selon la même convention. Une boucle peut lire ou modifier cet état pour décider si elle doit continuer. Définissez clairement sa condition d’arrêt afin d’éviter qu’elle ne tourne indéfiniment.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

keep_running=1
step=0

while (( keep_running == 1 )); do
    (( step += 1 ))
    printf 'Step %d.\n' "$step"
    if (( step >= 3 )); then
        keep_running=0
    fi
done

Les commandes arithmétiques renvoient un statut qui dépend de la valeur de l’expression. Ici, l’incrément est positif et la condition de boucle utilise l’indicateur stocké pour arrêter la boucle lorsque le compteur atteint trois.

Erreurs courantes avec les booléens dans Bash

• Ne supposez pas que Bash interprète 0 comme true et 1 comme false. Cette correspondance est une convention que vous définissez ; le statut d’une commande shell utilise zéro pour indiquer une réussite et une valeur non nulle pour indiquer un échec.
• N’exécutez pas une variable arbitraire comme une commande pour vérifier si elle vaut true. Comparez sa valeur ou utilisez une expression conditionnelle.
• Mettez les expansions de variables entre guillemets dans les tests avec un seul crochet, comme dans [ "$name" = "ready" ]. Pour les nombres, utilisez (( number == 1 )) ou mettez les opérandes entre guillemets dans un test numérique.
• Souvenez-vous que && et || réagissent à la réussite d’une commande, et non aux mots true et false stockés dans une variable.

Choisissez une convention pour vos indicateurs, appliquez-la de façon cohérente dans les affectations et les comparaisons, et utilisez le statut des commandes pour vérifier la réussite d’une opération.