J'ai appris à bash cette semaine et j'ai rencontré un hic.

#!/bin/sh

if [ false ]; then
    echo "True"
else
    echo "False"
fi

Cela produira toujours True même si la condition semble indiquer le contraire. Si je supprime les crochets, []cela fonctionne, mais je ne comprends pas pourquoi.

Vous exécutez la commande [(aka test) avec l'argument "false", sans exécuter la commande false. Puisque "false" est une chaîne non vide, la testcommande réussit toujours. Pour exécuter réellement la commande, supprimez la [commande.

if false; then
   echo "True"
else
   echo "False"
fi

Un aperçu booléen rapide pour Bash

La ifdéclaration prend une commande comme argument (comme le font &&, ||etc.). Le code de résultat entier de la commande est interprété comme un booléen (0 / null = true, 1 / else = false).

L' testinstruction prend des opérateurs et des opérandes comme arguments et renvoie un code de résultat au même format que if. Un alias de l' testinstruction est [, qui est souvent utilisé avec ifpour effectuer des comparaisons plus complexes.

Les instructions trueet falsene font rien et renvoient un code de résultat (0 et 1, respectivement). Ils peuvent donc être utilisés comme littéraux booléens dans Bash. Mais si vous placez les instructions dans un endroit où elles sont interprétées comme des chaînes, vous rencontrerez des problèmes. Dans ton cas:

if [ foo ]; then ... # "if the string 'foo' is non-empty, return true"
if foo; then ...     # "if the command foo succeeds, return true"

Alors:

if [ true  ] ; then echo "This text will always appear." ; fi;
if [ false ] ; then echo "This text will always appear." ; fi;
if true      ; then echo "This text will always appear." ; fi;
if false     ; then echo "This text will never appear."  ; fi;

Ceci est similaire à faire quelque chose comme echo '$foo'contre echo "$foo".

Lors de l'utilisation de l' testinstruction, le résultat dépend des opérateurs utilisés.

if [ "$foo" = "$bar" ]   # true if the string values of $foo and $bar are equal
if [ "$foo" -eq "$bar" ] # true if the integer values of $foo and $bar are equal
if [ -f "$foo" ]         # true if $foo is a file that exists (by path)
if [ "$foo" ]            # true if $foo evaluates to a non-empty string
if foo                   # true if foo, as a command/subroutine,
                         # evaluates to true/success (returns 0 or null)

En bref , si vous voulez juste tester quelque chose comme réussite / échec (aka "vrai" / "faux"), alors passez une commande à votre instruction ifou &&etc., sans crochets. Pour des comparaisons complexes, utilisez des parenthèses avec les opérateurs appropriés.

^{_{Et oui, je suis conscient qu'il n'y a pas de type booléen natif dans Bash, et que ifet [et truesont techniquement des "commandes" et non des "instructions"; ce n'est qu'une explication fonctionnelle très basique.}}

J'ai trouvé que je peux faire une logique de base en exécutant quelque chose comme:

A=true
B=true
if ($A && $B); then
    C=true
else
    C=false
fi
echo $C

L'utilisation de vrai / faux supprime un certain encombrement de parenthèses ...

#! /bin/bash    
#  true_or_false.bash

[ "$(basename $0)" == "bash" ] && sourced=true || sourced=false

$sourced && echo "SOURCED"
$sourced || echo "CALLED"

# Just an alternate way:
! $sourced  &&  echo "CALLED " ||  echo "SOURCED"

$sourced && return || exit