Tentei declarar uma variável booleana em um script de shell usando a seguinte sintaxe:

variable=$false

variable=$true

Isso está correto? Além disso, se eu quisesse atualizar essa variável, usaria a mesma sintaxe? Finalmente, a sintaxe a seguir para usar variáveis ​​booleanas como expressões está correta?

if [ $variable ]

if [ !$variable ]

Resposta Revisada (12 de fevereiro de 2014)

the_world_is_flat=true
# ...do something interesting...
if [ "$the_world_is_flat" = true ] ; then
    echo 'Be careful not to fall off!'
fi

Resposta original

Advertências: https://stackoverflow.com/a/21210966/89391

the_world_is_flat=true
# ...do something interesting...
if $the_world_is_flat ; then
    echo 'Be careful not to fall off!'
fi

De: usando variáveis ​​booleanas no Bash

A razão pela qual a resposta original foi incluída aqui é porque os comentários anteriores à revisão em 12 de fevereiro de 2014 pertencem apenas à resposta original e muitos dos comentários estão errados quando associados à resposta revisada. Por exemplo, o comentário de Dennis Williamson sobre o bash embutido trueem 2 de junho de 2010 se aplica apenas à resposta original, não à revisada.

TL; DR

bool=true

if [ "$bool" = true ]

Problemas com a resposta de Miku ( original )

Eu não recomendo a resposta aceita ¹ . Sua sintaxe é bonita, mas tem algumas falhas.

Digamos que temos a seguinte condição.

if $var; then
  echo 'Muahahaha!'
fi

Nos seguintes casos ² , essa condição será avaliada como verdadeira e executará o comando aninhado.

# Variable var not defined beforehand. Case 1
var=''  # Equivalent to var="".        Case 2
var=    #                              Case 3
unset var  #                           Case 4
var='<some valid command>'  #          Case 5

Normalmente, você deseja que sua condição seja avaliada como verdadeira apenas quando sua variável "Boolean", varneste exemplo, estiver explicitamente definida como verdadeira. Todos os outros casos são perigosamente enganosos!

O último caso (# 5) é especialmente impertinente, porque executará o comando contido na variável (é por isso que a condição é avaliada como verdadeira para comandos válidos ^{3, 4} ).

Aqui está um exemplo inofensivo:

var='echo this text will be displayed when the condition is evaluated'
if $var; then
  echo 'Muahahaha!'
fi

# Outputs:
# this text will be displayed when the condition is evaluated
# Muahahaha!

Citar suas variáveis ​​é mais seguro, por exemplo if "$var"; then. Nos casos acima, você deve receber um aviso de que o comando não foi encontrado. Mas ainda podemos fazer melhor (veja minhas recomendações na parte inferior).

^{Veja também a explicação de Mike Holt da resposta original de Miku.}

Problemas com a resposta da Hbar

Essa abordagem também tem um comportamento inesperado.

var=false
if [ $var ]; then
  echo "This won't print, var is false!"
fi

# Outputs:
# This won't print, var is false!

Você esperaria que a condição acima fosse avaliada como falsa, portanto, nunca executando a instrução aninhada. Surpresa!

Citar o valor ( "false"), citar a variável ( "$var") ou usar testou em [[vez de [não faz diferença.

O que eu não recomendo:

Aqui estão algumas maneiras pelas quais eu recomendo que você verifique seus "booleanos". Eles funcionam como esperado.

bool=true

if [ "$bool" = true ]; then
if [ "$bool" = "true" ]; then

if [[ "$bool" = true ]]; then
if [[ "$bool" = "true" ]]; then
if [[ "$bool" == true ]]; then
if [[ "$bool" == "true" ]]; then

if test "$bool" = true; then
if test "$bool" = "true"; then

Eles são todos praticamente equivalentes. Você precisará digitar mais algumas teclas do que as abordagens nas outras respostas ⁵ , mas seu código será mais defensivo.

Notas de rodapé

1. A resposta de Miku foi editada e não contém mais falhas (conhecidas).
2. Não é uma lista exaustiva.
3. Um comando válido neste contexto significa um comando que existe. Não importa se o comando é usado corretamente ou incorretamente. Por exemplo man woman, ainda seria considerado um comando válido, mesmo que não exista essa página de manual.
4. Para comandos inválidos (inexistentes), o Bash simplesmente reclamará que o comando não foi encontrado.
5. Se você se preocupa com o comprimento, a primeira recomendação é a mais curta.

Parece haver algum mal-entendido aqui sobre o Bash embutido truee, mais especificamente, sobre como o Bash expande e interpreta expressões entre colchetes.

O código na resposta de Miku não tem absolutamente nada a ver com o embutido Bash true, nem /bin/true, nem qualquer outro sabor do truecomando. Nesse caso, truenada mais é do que uma simples cadeia de caracteres e truenunca é feita nenhuma chamada ao comando / builtin, nem pela atribuição da variável nem pela avaliação da expressão condicional.

O código a seguir é funcionalmente idêntico ao código na resposta do miku:

the_world_is_flat=yeah
if [ "$the_world_is_flat" = yeah ]; then
    echo 'Be careful not to fall off!'
fi

A única diferença aqui é que os quatro caracteres comparados são 'y', 'e', ​​'a' e 'h' em vez de 't', 'r', 'u' e 'e'. É isso aí. Não é feita nenhuma tentativa de chamar um comando ou um nome interno yeah, nem existe (no exemplo do miku) nenhum tipo de tratamento especial acontecendo quando o Bash analisa o token true. É apenas uma string e completamente arbitrária.

Atualização (19/02/2014): Depois de seguir o link na resposta do miku, agora vejo de onde vem parte da confusão. A resposta de Miku usa colchetes simples, mas o trecho de código ao qual ele vincula não usa colchetes. É apenas:

the_world_is_flat=true
if $the_world_is_flat; then
  echo 'Be careful not to fall off!'
fi

Ambos os trechos de código se comportam da mesma maneira, mas os colchetes mudam completamente o que está acontecendo sob o capô.

Aqui está o que Bash está fazendo em cada caso:

Sem colchetes:

1. Expanda a variável $the_world_is_flatpara a sequência "true".
2. Tente analisar a cadeia "true"como um comando.
3. Encontre e execute o truecomando (embutido ou /bin/true, dependendo da versão do Bash).
4. Compare o código de saída do truecomando (que é sempre 0) com 0. Lembre-se de que na maioria dos shells, um código de saída 0 indica sucesso e qualquer outra coisa indica falha.
5. Como o código de saída foi 0 (êxito), execute a cláusula ifda instruçãothen

Suportes:

1. Expanda a variável $the_world_is_flatpara a sequência "true".
2. Analisar a expressão condicional agora totalmente expandida, que é da forma string1 = string2. O =operador é o operador de comparação de strings do bash . Assim...
3. Faça uma comparação de cadeias em "true"e "true".
4. Sim, as duas cadeias eram iguais, portanto o valor da condicional é verdadeiro.
5. Execute a cláusula ifda instrução then.

O código sem colchetes funciona, porque o truecomando retorna um código de saída 0, que indica sucesso. O código entre colchetes funciona, porque o valor de $the_world_is_flaté idêntico à string literal trueno lado direito do =.

Apenas para esclarecer as questões, considere os dois trechos de código a seguir:

Este código (se executado com privilégios de root) irá reiniciar o seu computador:

var=reboot
if $var; then
  echo 'Muahahaha! You are going down!'
fi

Este código apenas imprime "Boa tentativa". O comando reboot não é chamado.

var=reboot
if [ $var ]; then
  echo 'Nice try.'
fi

Atualização (14-04-2014) Para responder à pergunta nos comentários sobre a diferença entre =e ==: AFAIK, não há diferença. O ==operador é um sinônimo específico do Bash =e, até onde eu vi, eles funcionam exatamente da mesma forma em todos os contextos.

Note, no entanto, que eu estou falando especificamente sobre os =e ==operadores de comparação de string usado em qualquer [ ]ou [[ ]]testes. Não estou sugerindo isso =e ==são intercambiáveis em todos os lugares no bash.

Por exemplo, você obviamente não pode fazer a atribuição de variáveis ==, como var=="foo"(bem, tecnicamente, você pode fazer isso, mas o valor de varserá "=foo", porque Bash não está vendo um ==operador aqui, está vendo um =operador (de atribuição), seguido por o valor literal ="foo", que acaba de se tornar "=foo").

Além disso, embora =e ==são intercambiáveis, você deve ter em mente que a forma como esses testes trabalho não depende se você estiver usando-o dentro [ ]ou [[ ]], e também sobre se ou não os operandos são cotados. Você pode ler mais sobre isso no Advanced Bash Scripting Guide: 7.3 Outros operadores de comparação (role para baixo até a discussão sobre =e ==).

Use expressões aritméticas.

#!/bin/bash

false=0
true=1

((false)) && echo false
((true)) && echo true
((!false)) && echo not false
((!true)) && echo not true

Resultado:

verdadeiro
não falso

Longa história curta:

Não há booleanos no Bash

O Bash tem expressões booleanas em termos de comparação e condições. Dito isto, o que você pode declarar e comparar no Bash são strings e números. É isso aí.

Onde quer que você veja trueou falseno Bash, é uma string ou um comando / builtin que é usado apenas para o código de saída.

Essa sintaxe ...

if true; then ...

é essencialmente ...

if COMMAND; then ...

A condição é verdadeira sempre que o comando retorna o código de saída 0. trueE falsesão programas internos do Bash e, às vezes, também programas independentes que não fazem nada além de retornar o código de saída correspondente.

O condicional acima é equivalente a:

COMMAND && ...

Ao usar colchetes ou o testcomando, você depende do código de saída dessa construção. Lembre-se disso [ ]e [[ ]]também são apenas comandos / componentes internos como qualquer outro. Assim ...

if [[ 1 == 1 ]]; then echo yes; fi

corresponde a

if COMMAND; then echo yes; fi

e o COMMANDaqui é[[ 1 == 1 ]]

A if..then..ficonstrução é apenas açúcar sintático. Você sempre pode apenas executar os comandos separados por um e comercial duplo para o mesmo efeito:

[[ 1 == 1 ]] && echo yes

Ao usar truee falsenessas construções de teste, você está realmente apenas passando a string "true"ou "false"para o comando testing. Aqui está um exemplo:

Acredite ou não, mas essas condições estão produzindo o mesmo resultado :

if [[ false ]]; then ...
if [[ "false" ]]; then ...
if [[ true ]]; then ...
if [[ "true" ]]; then ...

TL; DR; sempre compare com strings ou números

Para deixar isso claro para os futuros leitores, eu recomendaria sempre usar aspas truee false:

FAZ

if [[ "${var}" == "true" ]]; then ...
if [[ "${var}" == "false" ]]; then ...
if [[ -n "${var:-}" ]]; then echo "var is not empty" ...

NÃO

if [ ... ]; then ...  # Always use double square brackets in bash!
if [[ "${var}" ]]; then ...  # This is not as clear or searchable as -n
if [[ "${var}" != true ]]; then ...  # Creates impression of Booleans
if [[ "${var}" -eq "true" ]]; then ...  # `-eq` is for numbers and doesn't read as easy as `==`

Talvez

if [[ "${var}" != "true" ]]; then ...  # Creates impression of Booleans. It can be used for strict checking of dangerous operations. This condition is false for anything but the literal string "true".

Há muito tempo, quando tudo o que tínhamos era sh, os booleanos eram manipulados, contando com uma convenção do testprograma em que testretornava um status de saída falso, se executado sem argumentos.

Isso permite pensar em uma variável que não está definida como falsa e a variável definida como qualquer valor como verdadeira. Hoje, testé um componente interno do Bash e é comumente conhecido por seu alias de um caractere [(ou um executável para usar em conchas sem ele, como observa o dolmen):

FLAG="up or <set>"

if [ "$FLAG" ] ; then
    echo 'Is true'
else
    echo 'Is false'
fi

# Unset FLAG
#    also works
FLAG=

if [ "$FLAG" ] ; then
    echo 'Continues true'
else
    echo 'Turned false'
fi

Por causa das convenções de citação, os criadores de scripts preferem usar o comando composto [[que imita test, mas possui uma sintaxe melhor: variáveis ​​com espaços não precisam ser citadas; pode-se usar &&e ||como operadores lógicos com precedência estranha, e não há limitações de POSIX no número de termos.

Por exemplo, para determinar se FLAG está definido e COUNT é um número maior que 1:

FLAG="u p"
COUNT=3

if [[ $FLAG  && $COUNT -gt '1' ]] ; then
    echo 'Flag up, count bigger than 1'
else
    echo 'Nope'
fi

Esse material pode ficar confuso quando são necessários espaços, cadeias de comprimento zero e variáveis ​​nulas e também quando seu script precisa trabalhar com vários shells.

Como posso declarar e usar variáveis ​​booleanas em um script de shell?

Ao contrário de muitas outras linguagens de programação, o Bash não segrega suas variáveis ​​por "tipo". [1]

Então a resposta é bem clara. Não há nenhuma variável booleana no Bash.

Contudo:

Usando uma declaração declare, podemos limitar a atribuição de valor a variáveis. [2]

#!/bin/bash
declare -ir BOOL=(0 1) # Remember BOOL can't be unset till this shell terminates
readonly false=${BOOL[0]}
readonly true=${BOOL[1]}

# Same as declare -ir false=0 true=1
((true)) && echo "True"
((false)) && echo "False"
((!true)) && echo "Not True"
((!false)) && echo "Not false"

A ropção in declaree readonlyé usada para declarar explicitamente que as variáveis ​​são somente leitura . Espero que o objetivo seja claro.

Em vez de fingir um booleano e deixar uma armadilha para futuros leitores, por que não usar um valor melhor do que verdadeiro e falso?

Por exemplo:

build_state=success
if something-horrible; then
  build_state=failed
fi

if [[ "$build_state" == success ]]; then
  echo go home; you are done
else
  echo your head is on fire; run around in circles
fi

POSIX (Interface de sistema operacional portátil)

Sinto falta aqui do ponto chave, que é a portabilidade. É por isso que meu cabeçalho possui o POSIX em si.

Basicamente, todas as respostas votadas estão corretas, com a exceção de serem específicas do Bash em demasia.

Basicamente, desejo apenas adicionar mais informações sobre portabilidade.

1. [e ]colchetes como em [ "$var" = true ]não são necessários, e você pode omiti-los e usar o testcomando diretamente:

   test "$var" = true && yourCodeIfTrue || yourCodeIfFalse

   Nota importante: não recomendo mais isso , pois está sendo preterido lentamente e mais difícil combinar várias instruções.

2. Imagine o que essas palavras truee falsedizer para o shell, teste você mesmo:

   echo $(( true ))

   0

   echo $(( false ))

   1

   Mas usando aspas:

   echo $(( "true" ))

   bash: "true": syntax error: operand expected (error token is ""true"")
   sh (dash): sh: 1: arithmetic expression: expecting primary: ""true""

   O mesmo vale para:

   echo $(( "false" ))

   O shell não pode interpretá-lo além de uma string. Espero que você esteja tendo a idéia de como é bom usar palavras-chave adequadas sem aspas .

   Mas ninguém disse isso em respostas anteriores.

3. O que isto significa? Bem, várias coisas.

   • Você deve se acostumar com as palavras-chave booleanas que são tratadas como números, ou seja, true= 0e false= 1, lembre-se de que todos os valores diferentes de zero são tratados como números false.

   • Como eles são tratados como números, você também deve tratá-los assim, ou seja, se você definir a variável, diga:

     var_bool=true
     echo "$var_bool"

      true

     você pode criar um valor oposto com:

     var_bool=$(( 1 - $var_bool ))  # same as $(( ! $var_bool ))
     echo "$var_bool"

     1

   Como você pode ver por si mesmo, o shell imprime truestring pela primeira vez em que você o usa, mas desde então tudo funciona através do número que 0representa trueou 1representa false, respectivamente.

Finalmente, o que você deve fazer com todas essas informações

• Primeiro, um bom hábito seria atribuir em 0vez de true; 1em vez de false.

• O segundo bom hábito seria testar se a variável é / não é igual a zero:

  if [ "$var_bool" -eq 0 ]; then
       yourCodeIfTrue
  else
       yourCodeIfFalse
  fi

Com relação à sintaxe, esta é uma metodologia simples que eu uso (por exemplo) para gerenciar de forma consistente e saudável a lógica booleana:

# Tests
var=
var=''
var=""
var=0
var=1
var="abc"
var=abc

if [[ -n "${var}" ]] ; then
    echo 'true'
fi
if [[ -z "${var}" ]] ; then
    echo 'false'
fi

# Results
# var=        # false
# var=''      # false
# var=""      # false
# var=0       # true
# var=1       # true
# var="abc"   # true
# var=abc     # true

Se a variável nunca for declarada, a resposta é: # false

Portanto, uma maneira simples de definir uma variável como verdadeira (usando essa metodologia de sintaxe) seria var=1,; inversamente var=''.

Referência:

-n = True se o comprimento da string var for diferente de zero.

-z = True se o comprimento da string var for zero.

Em muitas linguagens de programação, o tipo booleano é, ou é implementado como, um subtipo de número inteiro, em que truese comporta 1e falsese comporta como 0:

• Booleano em C

• Booleano em Python

• Booleano em Java

Matematicamente , a álgebra booleana se assemelha ao módulo aritmético inteiro 2. Portanto, se um idioma não fornecer o tipo booleano nativo, a solução mais natural e eficiente é usar números inteiros. Isso funciona com quase qualquer idioma. Por exemplo, no Bash, você pode:

# val=1; ((val)) && echo "true" || echo "false"
true
# val=0; ((val)) && echo "true" || echo "false"
false

festança do homem :

((expressão))

A expressão é avaliada de acordo com as regras descritas abaixo em AVALIAÇÃO ARITMÉTICA. Se o valor da expressão for diferente de zero, o status de retorno será 0; caso contrário, o status de retorno é 1. Isso é exatamente equivalente a deixar "expressão".

Bill Parker está sendo rejeitado , porque suas definições são revertidas da convenção de código normal. Normalmente, true é definido como 0 e false é definido como diferente de zero. 1 funcionará para false, assim como 9999 e -1. O mesmo com os valores de retorno da função - 0 é sucesso e qualquer coisa diferente de zero é falha. Desculpe, ainda não tenho credibilidade nas ruas para votar ou responder diretamente a ele.

Bash recomenda o uso de colchetes agora como um hábito, em vez de colchetes simples, e o link que Mike Holt deu explica as diferenças de como eles funcionam. 7.3 Outros operadores de comparação

Por um lado, -eqé um operador numérico, portanto, ter o código

#**** NOTE *** This gives error message *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then

emitirá uma instrução de erro, esperando uma expressão inteira. Isso se aplica a qualquer parâmetro, pois também não é um valor inteiro. No entanto, se colocarmos colchetes duplos em torno dele, ele não emitirá uma declaração de erro, mas produzirá um valor errado (bem, em 50% das permutações possíveis). Ele avaliará como [[0-eq verdadeiro]] = sucesso, mas também para [[0-eq falso]] = sucesso, o que está errado (hmmm .... e quanto a esse valor embutido ser um valor numérico?).

#**** NOTE *** This gives wrong output *****
The_world_is_flat=true;
if [[ "${The_world_is_flat}" -eq true ]]; then

Existem outras permutações do condicional que também produzirão resultados errados. Basicamente, qualquer coisa (que não seja a condição de erro listada acima) que define uma variável para um valor numérico e a compara com um verdadeiro / falso embutido ou define uma variável para um verdadeiro / falso embutido e a compara com um valor numérico. Além disso, qualquer coisa que defina uma variável como um verdadeiro / falso interno e faça uma comparação usando -eq. Portanto, evite -eqcomparações booleanas e evite usar valores numéricos para comparações booleanas. Aqui está um resumo das permutações que fornecerão resultados inválidos:

# With variable set as an integer and evaluating to true/false
# *** This will issue error warning and not run: *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then

# With variable set as an integer and evaluating to true/false
# *** These statements will not evaluate properly: *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then
#
if [[ "${The_world_is_flat}" -eq true ]]; then
#
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" = true ]]; then
#
if [ "${The_world_is_flat}" == true ]; then
#
if [[ "${The_world_is_flat}" == true ]]; then


# With variable set as an true/false builtin and evaluating to true/false
# *** These statements will not evaluate properly: *****
The_world_is_flat=true;
if [[ "${The_world_is_flat}" -eq true ]]; then
#
if [ "${The_world_is_flat}" = 0 ]; then
#
if [[ "${The_world_is_flat}" = 0 ]]; then
#
if [ "${The_world_is_flat}" == 0 ]; then
#
if [[ "${The_world_is_flat}" == 0 ]]; then

Então, agora para o que funciona. Use builtins verdadeiro / falso para sua comparação e suas avaliações (como observou Mike Hunt, não as coloque entre aspas). Em seguida, use um ou o sinal de igual simples ou duplo (= ou ==) e colchetes simples ou duplos ([] ou [[]]). Pessoalmente, gosto do sinal de igual duplo, porque me lembra comparações lógicas em outras linguagens de programação e aspas duplas apenas porque gosto de digitar. Então, estes funcionam:

# With variable set as an integer and evaluating to true/false
# *** These statements will work properly: *****
#
The_world_is_flat=true/false;
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" = true ]]; then
#
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" == true ]]; then

Aí está.

Minhas descobertas e sugestões diferem um pouco das outras postagens. Eu descobri que podia usar "booleanos" basicamente como se fosse em qualquer linguagem "normal", sem o "salto de arco" sugerido ...

Não há necessidade []ou comparações explícitas de strings ... Tentei várias distribuições Linux. Testei Bash, Dash e BusyBox . Os resultados sempre foram os mesmos. Não sei ao certo o que estão falando nas principais postagens votadas originais. Talvez os tempos tenham mudado e isso é tudo o que há para isso?

Se você definir uma variável como true, ela será avaliada posteriormente como "afirmativa" dentro de uma condicional. Defina como falsee avalia como "negativo". Muito simples! A única ressalva é que uma variável indefinida também é avaliada como verdadeira ! Seria bom se fizesse o contrário (como faria na maioria dos idiomas), mas esse é o truque - você só precisa inicializar explicitamente seus booleanos para true ou false .

Por que funciona dessa maneira? Essa resposta é dupla. A) verdadeiro / falso em um shell realmente significa "sem erro" vs "erro" (ou seja, 0 vs qualquer outra coisa). B) verdadeiro / falso não são valores - mas declarações em scripts de shell! Em relação ao segundo ponto, executar trueou falseem uma linha por si só define o valor de retorno do bloco em que você está nesse valor, ou seja, falseé uma declaração de "erro encontrado", onde verdadeiro "limpa" isso. Usá-lo com uma atribuição a uma variável "retorna" para a variável. Uma variável indefinida é avaliada como trueem uma condicional porque isso representa igualmente 0 ou "nenhum erro encontrado".

Veja o exemplo de linhas Bash e resultados abaixo. Teste você mesmo se quiser confirmar ...

#!/bin/sh

# Not yet defined...
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

myBool=true
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

myBool=false
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

Rendimentos

when set to
it evaluates to true
when set to true
it evaluates to true
when set to false
it evaluates to false

Aqui está um exemplo simples que funciona para mim:

temp1=true
temp2=false

if [ "$temp1" = true ] || [ "$temp2" = true ]
then
    echo "Do something." 
else
    echo "Do something else."
fi

Aqui está uma implementação de uma mão curta if true.

# Function to test if a variable is set to "true"
_if () {
    [ "${1}" == "true" ] && return 0
    [ "${1}" == "True" ] && return 0
    [ "${1}" == "Yes" ] && return 0
    return 1
}

Exemplo 1

my_boolean=true

_if ${my_boolean} && {
    echo "True Is True"
} || {
    echo "False Is False"
}

Exemplo 2

my_boolean=false
! _if ${my_boolean} && echo "Not True is True"

Achei as respostas existentes confusas.

Pessoalmente, eu só quero ter algo que pareça e funcione como C.

Este trecho funciona muitas vezes ao dia na produção:

snapshotEvents=true

if ($snapshotEvents)
then
    # Do stuff if true
fi

e para manter todos felizes, testei:

snapshotEvents=false

if !($snapshotEvents)
then
    # Do stuff if false
fi

O que também funcionou bem.

O $snapshotEventsavalia o conteúdo do valor da variável. Então você precisa do $.

Você realmente não precisa dos parênteses, eu apenas os acho úteis.

• Testado em: GNU Bash, versão 4.1.11 (2) - lançamento

• Guia Bash para Iniciantes , Machtelt Garrels, v1.11, 2008

Aqui está uma melhoria na resposta original do miku que aborda as preocupações de Dennis Williamson sobre o caso em que a variável não está definida:

the_world_is_flat=true

if ${the_world_is_flat:-false} ; then
    echo "Be careful not to fall off!"
fi

E para testar se a variável é false:

if ! ${the_world_is_flat:-false} ; then
    echo "Be careful not to fall off!"
fi

Sobre outros casos com um conteúdo desagradável na variável, esse é um problema com qualquer entrada externa alimentada em um programa.

Qualquer entrada externa deve ser validada antes de confiar nela. Mas essa validação deve ser feita apenas uma vez, quando essa entrada é recebida.

Ele não precisa afetar o desempenho do programa, fazendo isso em todos os usos da variável, como sugere Dennis Williamson .

Você pode usar shFlags .

Oferece a opção de definir: DEFINE_bool

Exemplo:

DEFINE_bool(big_menu, true, "Include 'advanced' options in the menu listing");

Na linha de comando, você pode definir:

sh script.sh --bigmenu
sh script.sh --nobigmenu # False

Este é um teste de velocidade sobre diferentes maneiras de testar os valores "booleanos" no Bash:

#!/bin/bash
rounds=100000

b=true # For true; b=false for false
type -a true
time for i in $(seq $rounds); do command $b; done
time for i in $(seq $rounds); do $b; done
time for i in $(seq $rounds); do [ "$b" == true ]; done
time for i in $(seq $rounds); do test "$b" == true; done
time for i in $(seq $rounds); do [[ $b == true ]]; done

b=x; # Or any non-null string for true; b='' for false
time for i in $(seq $rounds); do [ "$b" ]; done
time for i in $(seq $rounds); do [[ $b ]]; done

b=1 # Or any non-zero integer for true; b=0 for false
time for i in $(seq $rounds); do ((b)); done

Seria imprimir algo como

true is a shell builtin
true is /bin/true

real    0m0,815s
user    0m0,767s
sys     0m0,029s

real    0m0,562s
user    0m0,509s
sys     0m0,022s

real    0m0,829s
user    0m0,782s
sys     0m0,008s

real    0m0,782s
user    0m0,730s
sys     0m0,015s

real    0m0,402s
user    0m0,391s
sys     0m0,006s

real    0m0,668s
user    0m0,633s
sys     0m0,008s

real    0m0,344s
user    0m0,311s
sys     0m0,016s

real    0m0,367s
user    0m0,347s
sys     0m0,017s

Alternativa - use uma função

is_ok(){ :;}
is_ok(){ return 1;}
is_ok && echo "It's OK" || echo "Something's wrong"

Definir a função é menos intuitivo, mas verificar seu valor de retorno é muito fácil.

Bash realmente confunde a questão com os gostos de [, [[, ((, $((, etc.

Todos pisando nos espaços de código uns dos outros. Eu acho que isso é principalmente histórico, onde Bash tinha que fingir estar shocasionalmente.

Na maioria das vezes, eu posso escolher um método e seguir com ele. Nesse caso, tenho a tendência de declarar (de preferência em um arquivo de biblioteca comum com o qual posso incluir .meus scripts).

TRUE=1; FALSE=0

Posso então usar o ((... ))operador aritmético para testar dessa forma.

testvar=$FALSE

if [[ -d ${does_directory_exist} ]]
then
    testvar=$TRUE;
fi

if (( testvar == TRUE )); then
    # Do stuff because the directory does exist
fi

1. Você precisa ser disciplinado. Você testvardeve estar definido como $TRUEou $FALSEsempre.

2. Nos ((... ))comparadores, você não precisa do anterior $, o que o torna mais legível.

3. Eu posso usar ((... ))porque $TRUE=1e $FALSE=0, ou seja, valores numéricos.

4. A desvantagem é ter que usar um $ocasionalmente:

   testvar=$TRUE

   o que não é tão bonito.

Não é uma solução perfeita, mas abrange todos os casos que eu preciso desse teste.