Differenza tra [[expr1 || expr2]] e [[expr1]] || [[expr2]]

Considera due espressioni condizionali expr1e expr2, ad esempio $i -eq $je $k -eq $l. Possiamo scriverlo in bashvari modi. Ecco due possibilità

[[ expr1 || expr2 ]]

[[ expr1 ]] || [[ expr2 ]]

Sono abbastanza sicuro di aver visto qui dei consigli che il secondo dovrebbe essere preferito, ma non riesco a trovare prove a sostegno di questo.

Ecco uno script di esempio che sembra dimostrare che non ci sono differenze:

for i in 0 1
do
  for j in 0 1
  do
    for k in 0 1
    do
      for l in 0 1
      do
        if [[ $i -eq $j || $k -eq $l ]]; then printf "1-yes\t"; else printf "1-no\t"; fi
        if [[ $i -eq $j ]] || [[ $k -eq $l ]]; then printf "2-yes\n"; else printf "2-no\n"; fi
      done
    done
  done
done

e output che mostrano che entrambi i costrutti delle condizioni producono lo stesso risultato:

1-yes   2-yes
1-yes   2-yes
1-yes   2-yes
1-yes   2-yes
1-yes   2-yes
1-no    2-no
1-no    2-no
1-yes   2-yes
1-yes   2-yes
1-no    2-no
1-no    2-no
1-yes   2-yes
1-yes   2-yes
1-yes   2-yes
1-yes   2-yes
1-yes   2-yes

C'è qualche vantaggio nell'usare un costrutto rispetto all'altro?

Per punti bonus, stessa domanda ma generalizzando a più condizioni usando ||e &&. Ad esempio [[ expr1 && expr2 || expr3 ]],.

Penso che la raccomandazione che hai visto fosse per POSIX sh e / o il testcomando che funge anche da [comando, piuttosto che il [[costrutto che è apparso in ksh (grazie a Stéphane Chazelas per la punta) ed è usato anche per esempio in bash, zsh e altri conchiglie.

Nella maggior parte dei linguaggi, come C, quando una clausola è già nota per essere vera o falsa, non è necessario valutare le parti rimanenti a seconda dell'operazione: se vero non dopo un logico o seguirlo, se falso non dopo un logico e , ecc. Questo ovviamente permette ad esempio di fermarsi quando un puntatore è NULL e non provare a dereferenziarlo nella clausola successiva.

Ma il costrutto di sh[ expr1 -o expr2 ] (inclusa l'implementazione di bash) non lo fa: valuta sempre entrambe le parti, quando si vorrebbe valutare solo expr1 . Ciò potrebbe essere stato fatto per compatibilità con l' testimplementazione del comando. D'altra parte, sh ||e &&segue il solito principio: non valutato se non cambierà il risultato.

Quindi la differenza da notare sarebbe:

: > /tmp/effect #clear effect
if [ 1 -eq 1 -o $(echo 1; echo or-was-evaluated > /tmp/effect) -eq 1 ]; then
    echo true;
fi
cat /tmp/effect

che produce:

true
or-was-evaluated

Sopra, ognuno [avrebbe potuto essere sostituito con il /usr/bin/[quale è un alias del testcomando, usato prima che [fosse incorporato nelle shell.

Mentre i due successivi costrutti:

: > /tmp/effect #clear effect
if [ 1 -eq 1 ] || [ $(echo 1; echo or-was-evaluated > /tmp/effect) -eq 1 ]; then
    echo true;
fi
cat /tmp/effect

o

: > /tmp/effect #clear effect
if [[ 1 -eq 1 || $(echo 1; echo or-was-evaluated > /tmp/effect) -eq 1 ]]; then
    echo true;
fi
cat /tmp/effect

Produrrà truee lascerà solo effectvuoto: ||si comporta correttamente e ha [[corretto anche questo problema.

AGGIORNARE:

Come ha commentato @ StéphaneChazelas, ho perso diverse differenze relative alla domanda iniziale. Metterò qui solo il più importante (almeno per me): priorità degli operatori.

Mentre la shell non considererà la precedenza:

if true || true && false; then
    echo true
else
    echo false
fi

rese (perché non c'è precedenza e quindi prima true || trueviene valutata, quindi && false):

false

all'interno [[ ]]del &&operatore ha la precedenza sul ||:

if [[ 1 -eq 1 || 1 -eq 1 && 1 -eq 0 ]]; then
    echo true
else
    echo false
fi

rendimenti (perché 1 -eq 1 && 1 -eq 0è raggruppato ed è quindi il 2 ° membro di ||):

true

almeno per ksh , bash , zsh .

Quindi [[ ]]ha migliorato il comportamento su entrambi [ ]gli operatori logici diretti e shell.