Il test o [o [[è più portatile sia tra shell bash che tra altre shell?

Vedo che posso fare

$ [ -w /home/durrantm ] && echo "writable"
writable

o

$ test -w /home/durrantm && echo "writable"
writable

o

$ [[ -w /home/durrantm ]] && echo "writable"
writable

Mi piace usare la terza sintassi. Sono equivalenti in tutti i modi e per tutti i casi negativi e marginali? Ci sono differenze nella portabilità, ad esempio tra bash su Ubuntu e su OS X o versioni bash precedenti / precedenti, ad esempio prima / dopo 4.0 ed entrambi espandono le espressioni allo stesso modo?

[è sinonimo del testcomando ed è contemporaneamente un comando incorporato e un comando separato. Ma [[è una parola chiave bash e funziona solo in alcune versioni. Quindi, per motivi di portabilità, è meglio usare single []otest

[ -w "/home/durrantm" ] && echo "writable"

Sì, ci sono differenze. I più portatili sono testo [ ]. Entrambi fanno parte delle specifiche POSIXtest .

Il if ... ficostrutto è anche definito da POSIX e dovrebbe essere completamente portatile.

Il [[ ]]è una kshcaratteristica che è presente anche in alcune versioni di bash( tutti quelli moderni ), in zshe forse in altri, ma non è presente nella sho dasho le varie altre shell più semplici.

Così, per rendere i vostri script portatile, usare [ ], testo if ... fi.

Si noti che [] && cmdnon è lo stesso della if .. ficostruzione.

A volte il suo comportamento è abbastanza simile e puoi usarlo al [] && cmdposto di if .. fi. Ma solo a volte. Se hai più di un comando da eseguire se la condizione o hai bisogno di if .. else .. fistare attento e supplica la logica.

Un paio di esempi:

[ -z "$VAR" ] && ls file || echo wiiii

Non è lo stesso di

if [ -z $VAR ] ; then
  ls file
else
  echo wiii
fi

perché se lsfallirà, echoverrà eseguito che non accadrà if.

Un altro esempio:

[ -z "$VAR" ] && ls file && echo wiii

non è lo stesso di

if [ -z "$VAR" ] ; then
   ls file
   echo $wiii
fi

sebbene questa costruzione agirà allo stesso modo

[ -z "$VAR" ] && { ls file ; echo wiii ; }

si prega di notare che ;dopo l'eco è importante e deve essere lì.

Quindi, riprendendo la frase sopra possiamo dire

[] && cmd == se il primo comando ha esito positivo, eseguire il successivo

if .. fi == if condition (che potrebbe anche essere il comando test) quindi eseguire i comandi

Quindi solo per portabilità [e [[uso [.

ifè compatibile POSIX. Quindi, se devi scegliere tra [e ifscegliere guardando il tuo compito e il comportamento previsto.

In realtà è quello &&che sta sostituendo il if, non il test: ifun'istruzione nella shell scripting verifica se un comando ha restituito uno stato di uscita "riuscito" (zero); nel tuo esempio, il comando è [.

Quindi, in realtà ci sono due cose che stai variando qui: il comando utilizzato per eseguire il test e la sintassi utilizzata per eseguire il codice in base al risultato di quel test.

Comandi di test:

• testè un comando standardizzato per la valutazione delle proprietà di stringhe e file; nel tuo esempio, stai eseguendo il comandotest -w /home/durrantm
• [è un alias di quel comando, ugualmente standardizzato, che ha un ultimo argomento obbligatorio ]per apparire come un'espressione tra parentesi; non farti ingannare, è ancora solo un comando (potresti persino scoprire che il tuo sistema ha un file chiamato /bin/[)
• [[è una versione estesa del comando test incorporato in alcune shell, ma non fa parte dello stesso standard POSIX; include opzioni extra che non stai utilizzando qui

Espressioni condizionali:

• L' &&operatore ( qui standardizzato ) esegue un'operazione AND logica, valutando due comandi e restituendo 0 (che rappresenta vero) se entrambi restituiscono 0; valuterà il secondo comando solo se il primo ha restituito zero, quindi può essere usato come un semplice condizionale
• Il if ... then ... ficostrutto ( standardizzato qui ) usa lo stesso metodo di giudicare la "verità", ma consente un elenco composto di affermazioni nella thenclausola, piuttosto che il singolo comando offerto da un &&cortocircuito, e fornisce elife elseclausole, che sono difficili da scrivere usando solo &&e ||. Si noti che non ci sono parentesi attorno alla condizione in ifun'istruzione .

Pertanto, i seguenti sono tutti rendering ugualmente portatili e del tutto equivalenti del tuo esempio:

• test -w /home/durrantm && echo "writable"
• [ -w /home/durrantm ] && echo "writable"
• if test -w /home/durrantm; then echo "writable"; fi
• if [ -w /home/durrantm ]; then echo "writable"; fi

Mentre i seguenti sono anche equivalenti, ma meno portatili a causa della natura non standard di [[:

• [[ -w /home/durrantm ]] && echo "writable"
• if [[ -w /home/durrantm ]]; then echo "writable"; fi

Per la portabilità, utilizzare test/ [. Ma se non hai bisogno della portabilità, per il bene della sanità mentale di te stesso e degli altri che leggi la tua sceneggiatura [[. :)

Vedi anche What is the difference between test, [ and [[ ?in BashFAQ .

Se vuoi la portabilità al di fuori del mondo alla Bourne, allora:

test -w /home/durrantm && echo writable

è il più portatile. Funziona nelle conchiglie del Bourne cshe nelle rcfamiglie.

test -w /home/durrantm && echo "writable"

output sarebbe "writable"invece writablein gusci della rcfamiglia ( rc, es, akanga, in cui "non è speciale).

[ -w /home/durrantm ] && echo writable

non funzionerebbe nelle shell delle famiglie csho rcsui sistemi in cui non è presente un [comando $PATH(alcuni sono noti per avere testma non il suo [alias).

if [ -w /home/durrantm ]; then echo writabe; fi

funziona solo con conchiglie della famiglia Bourne.

[[ -w /home/durrantm ]] && echo writable

funziona solo in ksh(dove ha avuto origine) zshe bash(tutti e 3 nella famiglia Bourne).

Nessuno funzionerebbe nella fishshell dove è necessario:

[ -w /home/durrantm ]; and echo writable

o:

if [ -w /home/durrantm ]; echo writable; end

La mia ragione più importante per scegliere uno if foo; then bar; fio foo && barè se lo stato di uscita dell'intero comando è importante.

confrontare:

#!/bin/sh
set -e
foo && bar
do_baz

con:

#!/bin/sh
set -e
if foo; then bar; fi
do_baz

Potresti pensare che facciano lo stesso; tuttavia se foofallisce (o è falso, a seconda del punto di vista), nel primo esempio do_baz non verrà eseguito, poiché lo script sarà uscito ... Il set -ecomando indica alla shell di uscire immediatamente se un comando restituisce un falso stato. Molto utile se stai facendo cose come:

cd /some/directory
rm -rf *

Non vuoi che lo script continui a funzionare se cdfallisce per qualsiasi motivo.