Como posso testar se uma variável está vazia ou contém apenas espaços?

A seguinte sintaxe do bash verifica se paramnão está vazia:

 [[ !  -z  $param  ]]

Por exemplo:

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

Sem saída e tudo bem.

Mas quando paramestá vazio, exceto por um (ou mais) caracteres de espaço, o caso é diferente:

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

"Eu não sou zero" é emitido.

Como posso alterar o teste para considerar variáveis ​​que contêm apenas caracteres de espaço como vazias?

Primeiro, observe que o -zteste é explicitamente para:

o comprimento da corda é zero

Ou seja, uma string contendo apenas espaços não deve ser verdadeira abaixo -z, porque tem um comprimento diferente de zero.

O que você deseja é remover os espaços da variável usando a expansão do parâmetro de substituição de padrão :

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

Isso expande a paramvariável e substitui todas as correspondências do padrão (um único espaço) por nada; portanto, uma sequência que possui apenas espaços será expandida para uma sequência vazia.

O âmago da questão de como isso funciona é que ${var/pattern/string}substitui a primeira partida mais longa de patterncom string. Quando patterncomeça com /(como acima), substitui todas as correspondências. Como a substituição está vazia, podemos omitir o final /e o stringvalor:

$ {parâmetro / padrão / string}

O padrão é expandido para produzir um padrão, assim como na expansão do nome do arquivo. O parâmetro é expandido e a correspondência mais longa do padrão em relação ao seu valor é substituída por string . Se o padrão começar com '/', todas as correspondências do padrão serão substituídas por uma sequência . Normalmente, apenas a primeira partida é substituída. ... Se a sequência for nula, as correspondências do padrão serão excluídas e o padrão / a seguir poderá ser omitido.

Depois de tudo isso, acabamos ${param// }excluindo todos os espaços.

_{Observe que, embora esteja presente em ksh(onde ele se originou) zshe bash, essa sintaxe não é POSIX e não deve ser usada em shscripts.}

A maneira mais fácil de verificar se uma string contém apenas caracteres em um conjunto autorizado é testar a presença de caracteres não autorizados. Portanto, em vez de testar se a cadeia contém apenas espaços, teste se a cadeia contém algum caractere que não seja o espaço. No bash, ksh ou zsh:

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

"Consiste apenas em espaços" inclui o caso de uma variável vazia (ou não definida).

Você pode testar qualquer caractere de espaço em branco. Use [[ $param = *[^[:space:]]* ]]para usar configurações de localidade ou qualquer lista explícita de caracteres de espaço em branco que você deseja testar, por exemplo, [[ $param = *[$' \t\n']* ]]para testar espaço, tabulação ou nova linha.

Combinar uma string com um padrão com =inside [[ … ]]é uma extensão ksh (também presente no bash e no zsh). Em qualquer estilo Bourne / POSIX, você pode usar a caseconstrução para combinar uma sequência com um padrão. Observe que os padrões de shell padrão são usados !para negar um conjunto de caracteres, e não ^como na maioria das sintaxes de expressão regular.

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

Para testar caracteres em branco, a $'…'sintaxe é específica para ksh / bash / zsh; você pode inserir esses caracteres no seu script literalmente (observe que uma nova linha terá que estar entre aspas, pois a barra invertida + a nova linha se expandirá para nada) ou gerá-las, por exemplo

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

Para diferenciar entre em branco , não em branco , vazio e não definido :

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

[:blank:]é para caracteres de espaçamento horizontal (espaço e tabulação em ASCII, mas provavelmente há mais alguns no seu código do idioma; alguns sistemas incluirão o espaço sem quebra (quando disponível), outros não). Se você quiser caracteres de espaçamento vertical também (como nova linha ou feed de formulário), substitua [:blank:]por [:space:].

O único motivo restante para escrever um script de shell, em vez de um script em uma boa linguagem de script, é se a portabilidade extrema é uma preocupação primordial. O legado /bin/shé a única coisa que você pode ter certeza, mas o Perl, por exemplo, tem mais probabilidade de estar disponível em várias plataformas do que o Bash. Portanto, nunca escreva scripts de shell que usem recursos que não sejam verdadeiramente universais - e lembre-se de que vários fornecedores proprietários de Unix congelaram seu ambiente de shell antes do POSIX.1-2001 .

Existe uma maneira portátil de fazer esse teste, mas você precisa usar tr:

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

(O valor padrão de $IFS, convenientemente, é um espaço, uma guia e uma nova linha.)

(O printfpróprio built-in é muito portátil, mas confiar nele é muito menos complicado do que descobrir qual a sua variante echo).

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

Para testar se a variável está vazia ou contém espaços, você também pode usar este código:

${name:?variable is empty}

Para testar se uma variável está desmarcada, vazia (tem um valor nulo) ou contém apenas espaços:

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

Explicação:

• A expansão de ${param%%[! ]*}remove do primeiro não espaço até o fim.
• Isso deixa apenas os espaços principais.
• A próxima expansão remove os espaços iniciais da variável.
• Se o resultado estiver vazio, a variável estava vazia para começar.
• Ou, se a variável não estava vazia, a remoção dos espaços iniciais a deixava vazia.
• Se o resultado estiver vazio -z, faça eco empty.

O acima é compatível com POSIX e é executado em qualquer descendente de Bourne.

Se você deseja estender isso para também as guias, inclua uma guia explícita:

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

ou use uma variável com os caracteres que você precisa remover:

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

ou você pode usar alguma "expressão de classe de caractere" POSIX (em branco significa espaço e guia):

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

Mas isso falhará em mksh, lksh e nobre.

Tente o seguinte:

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

zero