Risposte:
Che controlla che $1
sia vuoto, anche se dovrebbe essere citato (identico a [ -z "$1" ]
). Alcune shell molto vecchie non gestivano correttamente le stringhe vuote, quindi gli autori di script portatili hanno adottato questo stile di controllo. Non è stato necessario per decenni, ma la gente lo fa ancora così perché la gente lo fa ancora così.
[ x$1 = x ]
non è ancora corretta, ma [ "x$1" = x ]
sarebbe per conchiglie che hanno un problema in cui $1
è !
o (
o -n
.... [ "" = "$1" ]
e case $1 in "")
sarebbe anche però OK.
[ -z "$1" ]
e [ "$1" = "" ]
ancora non funziona con / bin / sh di Solaris 10, il primo con trattino-0.5.4.
[ "$1" = "" ]
non funziona ancora con essa /bin/sh
(anche se non si desidera utilizzarla /usr/xpg4/bin/sh
lì /bin/sh
). trattino è stato fissato a tale proposito nel gennaio 2009.
Le parentesi quadre indicano un test , quindi [ x$1 = x]
senza if
o qualcosa di simile è insignificante, anche se sintatticamente ok.
Ha lo scopo di valutare vero se si x$1
espande x
e falso altrimenti, ma poiché non è quotato, se $1
è (es.) "Hey x", la shell vedrà x = x
, quindi questa costruzione non è ancora sicura.
Lo scopo del x = x
controllo è determinare se una variabile è vuota. Un modo più comune per farlo sarebbe usare solo le virgolette:
if [ "$1" = "" ]; then
Operatori di prova Bash -z
e -n
possono anche essere utilizzati, ma sono meno portabile su altri tipi di conchiglie. 1
La ragione per le virgolette, o il x$1
, è che il lato sinistro non si espande in nulla, il che sarebbe un errore sintattico:
if [ = x ] # No good!
if [ "" = "" ] # Okay.
if [ x = x ] # Also okay.
1. In realtà, test
può essere un'utilità autonoma ma la maggior parte delle shell la implementa come built-in; controlla la differenza tra which test
e type test
. Su GNU / Linux man test
afferma di fare riferimento al built-in, ma se si chiama (ad es.) /usr/bin/test
, Tale utility sembra implementare le funzionalità documentate nella pagina man, incluso -z
e -n
.
[ x$1 = x ]
valuterà anche vero se $1
è per esempio " -o x"
. Prova sh -xc '[ x$1 = x ] && echo yes' sh ' -o x'
. [ x$1 = x ]
è sbagliato e non ha senso.
if
utilizzare test
, è possibile utilizzarlo prima &&
, ||
o dopo while
o esaminare il risultato utilizzando$?
[ x$1 = x ]
Ha senso solo dentro zsh
. Ciò confronta la concatenazione di x
con il primo argomento della sceneggiatura con x
. Quindi il [
comando restituisce true se $1
è vuoto o non fornito.
[ $1 = "" ]
Non avrebbe funzionato perché, in zsh
quando una variabile vuota, non è citato in contesti della lista, si espande per alcun argomento a tutti, invece di un argomento vuoto, quindi se $1
fosse impostata o svuotare, il [
comando sarà solo ricevere come argomenti [
, =
la stringa vuota e da ]
cui non ha senso. [ -z "$1" ]
o [ "$1" = "" ]
sarebbe OK anche se come nelle shell POSIX.
Nelle shell / POSIX tipo Bourne, [ x$1 = x ]
non ha senso. Questo è l'operatore split + glob in qualche modo applicato alla concatenazione x
e al primo argomento dello script sperando che il risultato e =
e x
, e, ]
costituisca una valida espressione di test per il [
comando.
Per esempio, se lo script è stato passato un " = x -o x ="
argomento, [
avrebbe ricevuto questi argomenti: [
, x
, =
, x
, -o
, x
, =
, x
, ]
, che [
avrebbe capito come il confronto x
con x
e x
con x
e restituire true.
Se lo $1
fosse "* *"
, la shell passerebbe al [
comando l'elenco dei file nella directory corrente il cui nome inizia con x
(l'espansione glob di x*
), quindi l'elenco dei file non nascosti (espansione *
) ... che [
difficilmente sarà in grado per dare un senso a. Gli unici casi in cui ciò farebbe qualcosa di sensato è se $1
non contiene caratteri jolly o caratteri vuoti.
Ora, ciò che a volte trovi è il codice come:
[ "x$1" = x ]
Viene utilizzato per verificare se $1
è vuoto o non impostato.
Il modo normale di testare una variabile vuota o non impostata è:
[ -z "$1" ]
Ma ciò fallisce per alcuni valori di $1
like =
in alcune [
implementazioni (non POSIX) come quella incorporata nella shell Bourne come /bin/sh
su Solaris 10 e precedenti o su alcune vecchie versioni di dash
(fino a 0.5.4) o sh
su alcuni BSD.
Questo perché [
vede [
, -z
, =
, ]
e si lamenta di argomenti mancante alla =
operatore binario, invece di capire come l' -z
operatore unario applicato alla =
stringa.
Allo stesso modo, [ "$1" = "" ]
fallisce per alcune implementazioni di [
if $1
is !
or (
.
In quelle shell / [
implementazioni:
[ "x$1" = x ]
è sempre un test valido indipendentemente dal valore di $1
, quindi sono:
[ "" = "$1" ]
e:
[ -z "${1:+x}" ]
e
case $1 in "") ...; esac
Naturalmente, se si desidera verificare che non venga fornito alcun argomento, è necessario:
[ "$#" -eq 0 ]
Cioè, controlli il numero di argomenti passati allo script.
Si noti che al giorno d'oggi, [ -z "$var" ]
è chiaramente specificato da POSIX e non può fallire in conformant [
implementazioni (e bash
s' [
è ed è stato per decenni). Quindi dovresti essere in grado di fare affidamento su di esso in sh o bash
script POSIX .
x$1
sta concatenando due stringhe x
e $1
e se $ 1 è vuoto, x $ 1 è uguale a x e, di conseguenza, [x $ 1 = x] sarà vero. x = y
è usato per confrontare la stringa in sh
x$1
non viene citato, quindi su questi viene eseguita la divisione e il globbing.
[ x$1 = x ]
è vero se $1
è disinserito / null / vuoto o no.
Mettiti alla prova con:
TEST= ;[ x$TEST = x] && echo "TEST is unset"
e
TEST=lolz ;[ x$TEST = x ] && echo "TEST is unset"
[ x$1 = x ]
è anche vero se $1
è per esempio " -o x"
. Prova sh -xc '[ x$1 = x ] && echo yes' sh ' -o x'
. [ x$1 = x ]
è sbagliato e non ha senso.