A sintaxe da matéria não é igual?

Ao criar scripts, geralmente escrevo meus ifs com a seguinte sintaxe, pois é mais fácil entender que o que vem a seguir não é verdadeiro.

if [ ! "$1" = "$2" ]; then

Outros dizem que o caminho abaixo é melhor

if [ "$1" != "$2" ]; then

A questão é quando pergunto por que e se existem diferenças, ninguém parece ter resposta.

Então, existem diferenças entre as duas sintaxes? Um deles é mais seguro que o outro? Ou é apenas uma questão de preferência / hábito?

Além dos argumentos cosméticos / de preferência, um motivo pode ser o fato de haver mais implementações em que [ ! "$a" = "$b" ]falhas nos casos de canto do que com [ "$a" != "$b" ].

Ambos os casos devem ser seguros se as implementações seguirem o algoritmo POSIX , mas ainda hoje (início de 2018), ainda existem implementações que falham. Por exemplo, com a='(' b=')':

$ (a='(' b=')'; busybox test "$a" != "$b"; echo "$?")
0
$ (a='(' b=')'; busybox test ! "$a" = "$b"; echo "$?")
1

Com dashversões anteriores à 0.5.9, como a 0.5.8 encontrada shno Ubuntu 16.04, por exemplo:

$ a='(' b=')' dash -c '[ "$a" != "$b" ]; echo "$?"'
0
$ a='(' b=')' dash -c '[ ! "$a" = "$b" ]; echo "$?"'
1

(corrigido em 0.5.9, consulte https://www.mail-archive.com/[email protected]/msg00911.html )

Essas implementações tratam [ ! "(" = ")" ]como [ ! "(" "text" ")" ]é [ ! "text" ](teste se "texto" é a cadeia nula), enquanto o POSIX exige que seja [ ! "x" = "y" ](teste "x" e "y" para igualdade). Essas implementações falham porque executam o teste errado nesse caso.

Observe que há ainda outra forma:

! [ "$a" = "$b" ]

Esse requer um shell POSIX (não funcionará com o shell Bourne antigo).

Observe que várias implementações também tiveram problemas com [ "$a" = "$b" ](e [ "$a" != "$b" ]) e ainda se assemelham às [do /bin/shSolaris 10 (um shell Bourne, o shell POSIX está dentro /usr/xpg4/bin/sh). É por isso que você vê coisas como:

[ "x$a" != "x$b" ]

Em scripts, tentando ser portável para sistemas antigos.

A x != ysintaxe é melhor porque ! x == yé propensa a erros - requer conhecimento da precedência dos operadores, que difere de idioma para idioma. A sintaxe ! x == ypoderia ser interpretado como !(x == y)ou (!x) == y, dependendo prioridade !vs =.

Por exemplo, na c++negação ! vem antes do operador de comparação / relacional == , portanto, o seguinte código:

#include<iostream>

using namespace std;

int main()
{
  int x=1, y=2;
  if(     x  != y   ) cout<<"true"<<endl; else cout<<"false"<<endl;
  if(  !  x  == y   ) cout<<"true"<<endl; else cout<<"false"<<endl;
  if(  !( x  == y ) ) cout<<"true"<<endl; else cout<<"false"<<endl;
  if(   (!x) == y   ) cout<<"true"<<endl; else cout<<"false"<<endl;
}

retorna

true
false
true
false

Comportamento semelhante pode ser observado em muitas outras línguas, incluindo, por exemplo awk- uma ferramenta frequentemente usada no mundo Unix.

Por outro lado, reunir operadores via via x != ynão leva a nenhuma confusão como um padrão bem estabelecido. Além disso, tecnicamente falando !=muitas vezes não são dois, mas apenas um operador, portanto, deve ser ainda mais marginalmente mais rápido que avaliar do que comparar separadamente e depois negar. Portanto, embora ambas as sintaxes funcionem no bash, eu recomendaria seguir x != y, pois é muito mais fácil ler e manter o código que segue alguma lógica padrão.

Esse tipo de coisa é muito baseada em opiniões, pois a "resposta" depende muito da maneira como o cérebro de um indivíduo é conectado. Embora seja verdade que, semanticamente, NOT ( A == B )seja idêntico a (A != B ), um pode ser mais claro para uma pessoa e o outro para outra. Também é dependente do contexto. Por exemplo, se eu tiver um sinalizador definido, os significados podem ficar mais claros com uma sintaxe do que com outra:

if NOT ( fileHandleStatus == FS_OPEN )

em oposição a

if ( fileHandleStatus != FS_OPEN )