He estado aprendiendo bash esta semana y me encontré con un problema.

#!/bin/sh

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

Esto siempre dará como resultado True aunque la condición parezca indicar lo contrario. Si elimino los corchetes [], funciona, pero no entiendo por qué.

Está ejecutando el comando [(alias test) con el argumento "falso", no está ejecutando el comando false. Como "falso" es una cadena no vacía, el testcomando siempre tiene éxito. Para ejecutar realmente el comando, suelte el [comando.

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

Una cartilla booleana rápida para Bash

La ifafirmación adquiere un comando como argumento (como lo hacen &&, ||etc.). El código de resultado entero del comando se interpreta como booleano (0 / nulo = verdadero, 1 / más = falso).

La testdeclaración toma operadores y operandos como argumentos y devuelve un código de resultado en el mismo formato que if. Es un alias de la testdeclaración [, que a menudo se usa ifpara realizar comparaciones más complejas.

Las declaraciones truey falseno hacen nada y devuelven un código de resultado (0 y 1, respectivamente). Por lo tanto, pueden usarse como literales booleanos en Bash. Pero si coloca las declaraciones en un lugar donde se interpretan como cadenas, se encontrará con problemas. En tu caso:

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

Entonces:

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;

Esto es similar a hacer algo así como echo '$foo'frente echo "$foo".

Cuando se usa la testdeclaración, el resultado depende de los operadores utilizados.

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 resumen , si solo desea probar algo como pasar / fallar (también conocido como "verdadero" / "falso"), entonces pase un comando a su declaración ifo &&etc., sin corchetes. Para comparaciones complejas, use corchetes con los operadores adecuados.

^{_{Y sí, soy consciente de que no hay tal cosa como un tipo booleano nativo en Bash, y que ife [y trueson técnicamente "comandos" y no "declaraciones"; Esta es solo una explicación muy básica y funcional.}}

Descubrí que puedo hacer algo de lógica básica ejecutando algo como:

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

El uso de verdadero / falso elimina el desorden de paréntesis ...

#! /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