Come posso verificare se una variabile è vuota o contiene solo spazi?

La seguente sintassi bash verifica se paramnon è vuota:

 [[ !  -z  $param  ]]

Per esempio:

param=""
[[ !  -z  $param  ]] && echo "I am not zero"

Nessun output e va bene.

Ma quando paramè vuoto tranne uno (o più) caratteri di spazio, il caso è diverso:

param=" " # one space
[[ !  -z  $param  ]] && echo "I am not zero"

Viene visualizzato "I am not zero".

Come posso modificare il test per considerare vuote le variabili che contengono solo caratteri di spazio?

Innanzitutto, nota che il -ztest è esplicitamente per:

la lunghezza della stringa è zero

Cioè, una stringa contenente solo spazi non dovrebbe essere vera sotto -z, perché ha una lunghezza diversa da zero.

Quello che vuoi è rimuovere gli spazi dalla variabile usando l' espansione del parametro di sostituzione del modello :

[[ -z "${param// }" ]]

Questo espande la paramvariabile e sostituisce tutte le corrispondenze del modello (un singolo spazio) con nulla, quindi una stringa che contiene solo spazi verrà espansa in una stringa vuota.

Il nocciolo di come funziona è che ${var/pattern/string}sostituisce la prima partita più lunga di patterncon string. Quando patterninizia con /(come sopra), sostituisce tutte le partite. Poiché la sostituzione è vuota, possiamo omettere /il stringvalore finale e il valore:

$ {Parametro / modello / string}

Il modello viene espanso per produrre un modello proprio come nell'espansione del nome file. Il parametro viene espanso e la corrispondenza più lunga del modello rispetto al suo valore viene sostituita con stringa . Se il motivo inizia con '/', tutte le corrispondenze del motivo vengono sostituite con una stringa . Normalmente viene sostituita solo la prima partita. ... Se la stringa è nulla, le corrispondenze del modello vengono eliminate e il modello / seguente può essere omesso.

Dopo tutto ciò, finiamo ${param// }per eliminare tutti gli spazi.

_{Si noti che sebbene presente in ksh(dove ha avuto origine), zshe bash, quella sintassi non è POSIX e non dovrebbe essere usata negli shscript.}

Il modo semplice per verificare che una stringa contenga solo caratteri in un set autorizzato è verificare la presenza di caratteri non autorizzati. Pertanto, anziché verificare se la stringa contiene solo spazi, verifica se la stringa contiene caratteri diversi dallo spazio. In bash, ksh o zsh:

if [[ $param = *[!\ ]* ]]; then
  echo "\$param contains characters other than space"
else
  echo "\$param consists of spaces only"
fi

"Consiste solo di spazi" include il caso di una variabile vuota (o non impostata).

Potresti voler testare qualsiasi carattere di spazio bianco. Utilizzare [[ $param = *[^[:space:]]* ]]per utilizzare le impostazioni locali o qualsiasi elenco esplicito di caratteri di spazi bianchi per cui si desidera verificare, ad esempio [[ $param = *[$' \t\n']* ]]per verificare lo spazio, la scheda o la nuova riga.

La corrispondenza di una stringa con uno schema con =inside [[ … ]]è un'estensione ksh (presente anche in bash e zsh). In qualsiasi stile Bourne / POSIX, è possibile utilizzare il casecostrutto per abbinare una stringa a un modello. Si noti che i modelli di shell standard usano !per negare un set di caratteri, piuttosto che ^come nella maggior parte delle sintassi delle espressioni regolari.

case "$param" in
  *[!\ ]*) echo "\$param contains characters other than space";;
  *) echo "\$param consists of spaces only";;
esac

Per verificare i caratteri degli spazi bianchi, la $'…'sintassi è specifica di ksh / bash / zsh; puoi inserire questi caratteri nel tuo script letteralmente (nota che una nuova riga dovrà essere racchiusa tra virgolette, poiché la barra rovesciata + la nuova riga non si espande nel nulla) o generarli, ad es.

whitespace=$(printf '\n\t ')
case "$param" in
  *[!$whitespace]*) echo "\$param contains non-whitespace characters";;
  *) echo "\$param consists of whitespace only";;
esac

POSIXly:

case $var in
  (*[![:blank:]]*) echo '$var contains non blank';;
  (*) echo '$var contains only blanks or is empty or unset'
esac

Per distinguere tra vuoto , non vuoto , vuoto , non impostato :

case ${var+x$var} in
  (x) echo empty;;
  ("") echo unset;;
  (x*[![:blank:]]*) echo non-blank;;
  (*) echo blank
esac

[:blank:]è per i caratteri di spaziatura orizzontale (spazio e tabulazione in ASCII, ma probabilmente ce ne sono alcuni nella tua locale; alcuni sistemi includeranno lo spazio non-break (dove disponibile), altri no). Se vuoi anche caratteri di spaziatura verticale (come newline o feed di form), sostituiscili [:blank:]con [:space:].

L'unico motivo rimanente per scrivere uno script di shell, anziché uno script in un buon linguaggio di scripting, è se la portabilità estrema è una preoccupazione prioritaria. L'eredità /bin/shè l'unica cosa che puoi essere certo di avere, ma Perl, ad esempio, è più probabile che sia disponibile multipiattaforma rispetto a Bash. Pertanto, non scrivere mai script di shell che utilizzano funzionalità che non sono veramente universali e tenere presente che diversi fornitori Unix proprietari hanno bloccato il loro ambiente di shell prima di POSIX.1-2001 .

Esiste un modo portatile per eseguire questo test, ma è necessario utilizzare tr:

[ "x`printf '%s' "$var" | tr -d "$IFS"`" = x ]

(Il valore predefinito di $IFS, convenientemente, è uno spazio, una scheda e una nuova riga.)

(L'interno printfè di per sé portatile, ma fare affidamento su di esso è molto meno seccante di capire quale variante echohai.)

if [[ -n "${variable_name/[ ]*\n/}" ]]
then
    #execute if the the variable is not empty and contains non space characters
else
    #execute if the variable is empty or contains only spaces
fi

Per verificare se la variabile è vuota o contiene spazi, è anche possibile utilizzare questo codice:

${name:?variable is empty}

Per verificare se una variabile non è impostata, vuota (ha un valore null) o contiene solo spazi:

 [ -z "${param#"${param%%[! ]*}"}" ] && echo "empty"

Spiegazione:

• L'espansione di ${param%%[! ]*}rimuove dal primo non-spazio alla fine.
• Questo lascia solo gli spazi principali.
• L'espansione successiva rimuove gli spazi iniziali dalla variabile.
• Se il risultato è vuoto, la variabile era vuota per cominciare.
• Oppure, se la variabile non era vuota, la rimozione degli spazi iniziali la rendeva vuota.
• Se il risultato è vuoto -z, echo empty.

Quanto sopra è compatibile POSIX e funziona con qualsiasi discendente Bourne.

Se si desidera estenderlo anche alle schede, includere una scheda esplicita:

 [ -z "${param#"${param%%[!     ]*}"}" ] && echo "empty"

o usa una variabile con i caratteri che devi rimuovere:

 var=$' \t'   # in ksh, bash, zsh
 [ -z "${param#"${param%%[!$var]*}"}" ] && echo "empty"

oppure puoi usare alcune "espressioni di classe di caratteri" POSIX (spazio vuoto significa spazio e tabulazione):

 [ -z "${param#"${param%%[![:blank:]]*}"}" ] && echo "empty"

Ma ciò fallirà in mksh, lksh e posh.

Prova questo:

$ [[ -z \`echo $n\` ]] && echo zero

zero