Se outras condições no Bash

Você precisa verificar cada variável:

if [[ "$CHECKX" == "FALSE" || "$CHECKY" == "FALSE" ]] && [[ "$CHECKZ" == "FALSE" ]]; then
  echo "Condition not met"
fi

Quando você tinha if [[ "$CHECKX" || "$CHECKY" == "FALSE" ]], isso é apenas verificar se $CHECKXestá definido, ele apenas compara $CHECKYcom a string FALSE. Ilustrar:

$ CHECKX=foo
$ CHECKY=TRUE
$ [[ "$CHECKX" || "$CHECKY" == "FALSE" ]] && echo true
true
$ CHECKX=""
$ [[ "$CHECKX" || "$CHECKY" == "FALSE" ]] && echo true
$ 

Como você pode ver acima, a verificação só falhou quando CHECKXfoi definida como a string emtpy, então o teste [[ "$CHECKX" ]]foi avaliado como falso. Se for definido como qualquer coisa, incluindo 0, então falhará:

$ CHECKX=0
$ [[ "$CHECKX" || "$CHECKY" == "FALSE" ]] && echo true
true

Outros abordaram suas técnicas de codificação para armazenar e testar valores e variáveis ​​booleanas, então vou me concentrar apenas na lógica do seu código.

Quando você estiver trabalhando para entender uma função booleana multivariável, crie uma tabela verdade para ter certeza de qual deve ser a saída correta de sua função. Verifique se entendi sua postagem corretamente, mas acredito que para uma função Q(X,Y,Z)o valor de Qdepende de X, Ye Zda seguinte forma:

"Se X ou Y for falso e Z também for falso, então... as condições não serão atendidas."

Como você declarou isso de forma negativa, presumirei que, em todos os outros casos, a condição é atendida.

Um axioma comum na álgebra booleana é que em vez de construir uma função Q que resolva todos os casos, podemos construir duas subfunções Q1 e Q2 que resolvam partes exclusivas da tabela. Então podemos simplesmente usar ORos resultados de Q1 e Q2 para obter a solução final Q.

Por exemplo, seja Q1 a solução onde Xé FALSO, na metade superior da tabela. Observe que nesses quatro casos, as colunas Ze Qsão idênticas. A Ycoluna é irrelevante, então podemos dizer que quando Xfor FALSE, o resultado da função está diretamente relacionado a Z:

for X=FALSE, Q1 = !X && Z

Na metade inferior da tabela, onde Xé TRUE, o resultado da função Q2 está diretamente relacionado a Y || Z:

for X=TRUE, Q2 = X && (Y || Z)

Como Q1 e Q2 são definidos em domínios totalmente separados, podemos afirmar que o resultado Q será precisamente um ou outro. Aquilo é,

Q = Q1 || Q2

Agora precisamos combinar estes dois casos numa única fórmula booleana. É tentador simplesmente concatenar tudo, mas para uma fórmula booleana correta, temos que considerar a ordem de avaliação. Semelhante à álgebra normal, onde a multiplicação é realizada antes da adição, a álgebra booleana determina que a interseção (AND) seja realizada antes da união (OR). Portanto, colocaremos parênteses em torno das subexpressões.

Ou Xé falso e nosso resultado é Z:

if !X then Q1 = Z

Ou Xé verdade e nosso resultado é Y || Z:

if  X then Q2 = Y || Z

E nossa resposta é literalmente uma OU outra:

Q = (!X && Q1) || (X && Q2)

A avaliação de curto-circuito e a comutação da união nos permitiriam reafirmar isso como:

Q = (X && Q2) || (Q1)

Substituting for Q1 and Q2:

Q = (X && (Y || Z)) || (Z)

With parentheses only where needed:

Q = X && (Y || Z) || Z

which can also be written:

Q = Z || X && (Y || Z) 

When Z is true, the right side of the OR is irrelevant. When Z is false, the right side of the OR becomes:

X && (Y || FALSE)

or just:

X && Y

so our final function Q is:

Q = Z || X && Y

We can verify this against the truth table, because in every case where Z is true, Q is also true. In the four cases where Z is false, Q is true only when X and Y are both true.

Expressar seus requisitos em [múltiplos] negativos duplos ("Se CHECK_X ou CHECK_Y for falso e CHECK_Z também for falso , então informo ao usuário que as condições não foram atendidas.") torna muito mais difícil entendê-los e implementá-los do que se você expressasse eles de uma forma positiva.

Evite usar negativos como !ou notcomparações com qualquer variação em falseseus requisitos ou código e evite usar qualquer termo negativo como notem nomes de variáveis ​​pelo mesmo motivo - positivos são sempre mais fáceis de entender do que negativos e se você não tiver negativos então você não posso acabar com duplas negativas extremamente difíceis de entender.

Aqui está o que você disse que é sua exigência:

Se CHECK_X ou CHECK_Y for falso e CHECK_Z também for falso, informo ao usuário que as condições não foram atendidas.

e podemos traduzir diretamente seus requisitos em pseudocódigo como:

if ( ((CHECK_X == false) || (CHECK_Y == false)) && (CHECK_Z == false) ); then
    print 'conditions are not met'
else
    conditions are met so do nothing
fi

Agora, para tornar tudo menos negativo, se primeiro virarmos para que as if"condições sejam atendidas" (ou seja, positivas em vez de negativas) sejam a condição que está sendo testada, então ela se tornará:

if ! ( ((CHECK_X == false) || (CHECK_Y == false)) && (CHECK_Z == false) ); then
    conditions are met so do nothing
else
    print 'conditions are not met'
fi

Portanto, agora temos um ifteste que nos leva a um estado positivo de "condições foram atendidas", em vez de negativo, de "condições não atendidas ". Agora só precisamos tornar o ifteste em si positivo, em vez de negativo, fatorando o operador "não" inicial, !e alterando as comparações com falsepara comparações com true.

Se aplicarmos a álgebra booleana para mover a negação !dentro dos parênteses mais externos, a condição se tornará:

if ( !((CHECK_X == false) || (CHECK_Y == false)) || !(CHECK_Z == false) ); then
    conditions are met so do nothing
else
    print 'conditions are not met'
fi

e se aplicarmos o mesmo novamente para mover o primeiro !dentro da condição a que se aplica, obteremos:

if ( ( !(CHECK_X == false) && !(CHECK_Y == false) ) || !(CHECK_Z == false) ); then
    conditions are met so do nothing
else
    print 'conditions are not met'
fi

que podemos simplificar alterando cada um !...falsepara true:

if ( ((CHECK_X == true) && (CHECK_Y == true)) || (CHECK_Z == true) ); then
    conditions are met so do nothing
else
    print 'conditions are not met'
fi

e agora temos um ifteste totalmente positivo produzindo um resultado positivo "as condições foram atendidas" e de repente fica muito claro que sua exigência é simplesmente que se CHECK_Z ou ambos CHECK_X e CHECK_Y forem verdadeiros, então a condição foi atendida, caso contrário, é ' t e assim podemos implementar facilmente esse requisito usando um if-elsecomo acima ou de forma mais sucinta como:

$ cat tst.sh
#!/usr/bin/env bash

testit() {
    [[ (("$CHECK_X" == "TRUE") && ("$CHECK_Y" == "TRUE")) || ("$CHECK_Z" == "TRUE") ]] ||
        printf 'conditions are not met\n'
}

for CHECK_X in TRUE FALSE; do
    for CHECK_Y in TRUE FALSE; do
        for CHECK_Z in TRUE FALSE; do
            printf 'CHECK_X=%s, CHECK_Y=%s, CHECK_Z=%s %s\n' \
                    "$CHECK_X" "$CHECK_Y" "$CHECK_Z" "$(testit)"
        done
    done
done

$ ./tst.sh
CHECK_X=TRUE, CHECK_Y=TRUE, CHECK_Z=TRUE
CHECK_X=TRUE, CHECK_Y=TRUE, CHECK_Z=FALSE
CHECK_X=TRUE, CHECK_Y=FALSE, CHECK_Z=TRUE
CHECK_X=TRUE, CHECK_Y=FALSE, CHECK_Z=FALSE conditions are not met
CHECK_X=FALSE, CHECK_Y=TRUE, CHECK_Z=TRUE
CHECK_X=FALSE, CHECK_Y=TRUE, CHECK_Z=FALSE conditions are not met
CHECK_X=FALSE, CHECK_Y=FALSE, CHECK_Z=TRUE
CHECK_X=FALSE, CHECK_Y=FALSE, CHECK_Z=FALSE conditions are not met

I would focus on the readability of the logic flow in the code, so instead of writing a single complicated structure that does all the work, that later when you forgot about and need to understand you have to go through mental gymnastics, make the code into simple steps that are easy to follow.

For example, if I understand you correctly, if CHECK_Z is TRUE then you don't need to check on CHECK_X or CHECK_Y. So only if CHECK_Z is FALSE you have to check the others. I added a variable conditions_met, that you will use when you need to follow the program and print messages, for example.

I simplified the variable names for clarity, and assumed each one can have a boolean value, either 'TRUE' or 'FALSE' (in bash I'd use 0 and 1 maybe, not a string).

X="FALSE"
# X="TRUE"
Y="FALSE"
# Y="TRUE"
Z="FALSE"
# Z="TRUE"

# Set a default value for the conditions met that you will challenge
conditions_met="TRUE"
message="Conditions are met."

# The simpler case, Z value, only deal with the others if it's FALSE
if [[ "$Z" = "FALSE" ]]; then
    # If and only if Z is FALSE, check the value of the others
  if [[ "$X" = "FALSE" || "$Y" = "FALSE" ]]; then
    # Let the result of the operation be handled by another variable
    # that you can understand and follow easily
    conditions_met="FALSE"
  fi
fi

if [[ "$conditions_met" = "FALSE" ]]; then
  message="Conditions are NOT met."
fi

echo "$message"

If you want Booleans in BASH, than the closest to a real Boolean is using a
Number and the Shell Arithmetic.

Because: CHECK_X="true"; [[ $CHECK_X == "true" ]];
is a string comparison, where the right parameter is a glob pattern, if not quoted, and which then generates something like a boolean, exit code 0 or 1

tente aritmética do shell:

set +o histexpand # only needed in an interactive shell

declare -i CHECK_X=0 CHECK_Y=0 CHECK_Z=0   #-- Boolean 0 or 1 , false or true

# now you can use boolean syntax inside shell arithmetic ((...))
if (( (!CHECK_X || !CHECK_Y) && !CHECK_Z )); then echo "yep"; fi
if (( CHECK_X || CHECK_Y || !CHECK_Z )); then echo "pep"; fi

declare test="hello"  # with string
if (( CHECK_X && CHECK_Y && CHECK_Z && test=="hello" )); then echo ".."; fi

Honestamente, com todas as informações que você postou, é muito difícil escolher como você deseja que isso funcione.

Estou baseando minha solução abaixo em sua declaração da seguinte forma:

Preciso CHECK_Xque e CHECK_Zseja verdadeiro ou CHECK_Ye CHECK_Zseja verdadeiro antes que minha condição seja atendida.

Conforme discutido de outra forma, encadear condições negativas é um trabalho árduo. Para esse tipo de lógica, talvez seja melhor usar indevidamente a casedentro de uma função - e, em vez disso, verificar os pontos positivos.

checks(){
  case "$CHECK_X:$CHECK_Y:$CHECK_Z" in
    (TRUE:*:TRUE) true ;; # X and Z
    (*:TRUE:TRUE) true ;; # Y and Z
    (*) false
  esac
}

if checks ; then
  echo conditions met
else
  echo conditions not met
fi

Aqui está em ação

X=TRUE  Y=TRUE  Z=TRUE  conditions met
X=TRUE  Y=TRUE  Z=FALSE conditions not met
X=TRUE  Y=FALSE Z=TRUE  conditions met
X=TRUE  Y=FALSE Z=FALSE conditions not met
X=FALSE Y=TRUE  Z=TRUE  conditions met
X=FALSE Y=TRUE  Z=FALSE conditions not met
X=FALSE Y=FALSE Z=TRUE  conditions not met
X=FALSE Y=FALSE Z=FALSE conditions not met

Experimente on-line!

my take on it:

if [[ ( $CHECK_X == 'TRUE' && $CHECK_Y == 'TRUE' ) || ( $CHECK_Y == 'TRUE' && $CHECK_Z == 'TRUE' ) ]]
  then echo Condition is met
  else echo condition is not met
fi