Como determinar se uma variável bash está vazia?

Respostas:

1053

Isso retornará true se uma variável estiver desconfigurada ou definida como a sequência vazia ("").

if [ -z "$VAR" ];
duffbeer703
fonte
14
Isso inclui se uma variável estiver definida como um valor ""?
Brent
11
Sim, ele faz ... "-z" testa uma cadeia de comprimento zero.
187 David Z
91
if [ ! -z "$VAR" ];
Aaron Copley
263
o inverso -zé #-n if [ -n "$VAR" ];
Felipe Alvarez #
19
As aspas duplas garantem que a variável não seja dividida. Um simples $varem uma linha de comando será dividido por seu espaço em branco em uma lista de parâmetros, enquanto "$var"sempre será apenas um parâmetro. A citação de variáveis ​​geralmente é uma boa prática e impede que você use nomes de arquivos que contenham espaços em branco (entre outras coisas). Exemplo: depois de fazer a="x --help", tente cat $a- ele fornecerá a página de ajuda para cat. Então tente cat "$a"- dirá (geralmente) cat: x --help: No such file or directory. Em resumo, cite com antecedência e cite com frequência e você quase nunca se arrependerá.
Score_Under
247

No Bash, quando você não está preocupado com a portabilidade para shells que não o suportam, você sempre deve usar a sintaxe entre colchetes:

Qualquer um dos seguintes:

if [[ -z $variable ]]
if [[ -z "$variable" ]]
if [[ ! $variable ]]
if [[ ! "$variable" ]]

No Bash, usando colchetes duplos, as aspas não são necessárias. Você pode simplificar o teste para uma variável que faz conter um valor para:

if [[ $variable ]]

Essa sintaxe é compatível com ksh (pelo menos ksh93, de qualquer maneira). Ele não funciona em shell Bourne puros POSIX ou mais antigos, como sh ou dash.

Veja minha resposta aqui e o BashFAQ / 031 para obter mais informações sobre as diferenças entre colchetes duplos e únicos.

Você pode testar para ver se uma variável está especificamente desconfigurada (diferente de uma sequência vazia):

if [[ -z ${variable+x} ]]

onde o "x" é arbitrário.

Se você deseja saber se uma variável é nula, mas não está desmarcada:

if [[ -z $variable && ${variable+x} ]]
Dennis Williamson
fonte
1
Isso if [[ $variable ]]funcionou bem para mim e nem precisava do set -uexigido por uma das outras soluções propostas.
Teemu Leisti 14/09/12
3
Eu acho que isso é melhor do que a resposta aceita.
Qd
2
Por que você recomenda um recurso não portátil ao fazer isso não oferece benefícios?
Alastair Irvine
19
@AlastairIrvine: eu menciono portabilidade na primeira frase da minha resposta, o título e o corpo da pergunta contêm a palavra "Bash" e a pergunta é marcada como bash , e a estrutura de colchetes duplos oferece vantagens claras de várias maneiras. E não recomendo misturar estilos de colchetes por razões de consistência e manutenção. Se você precisar da portabilidade máxima e mínima do denominador comum, use em shvez de Bash. Se você precisar dos recursos aprimorados que ele fornece, use o Bash e use-o totalmente.
Dennis Williamson
2
@BrunoBronosky: Eu reverti a edição. Não há requisitos para ;no final. O thenpode ser na próxima linha sem um ponto e vírgula em tudo.
Dennis Williamson
230

Uma variável no bash (e qualquer shell compatível com POSIX) pode estar em um dos três estados:

  • incerto
  • definido para a sequência vazia
  • definido como uma sequência não vazia

Na maioria das vezes, você só precisa saber se uma variável está definida como uma sequência não vazia, mas ocasionalmente é importante distinguir entre a definição não definida e a definida como uma sequência vazia.

A seguir, exemplos de como você pode testar as várias possibilidades, e ele funciona no bash ou em qualquer shell compatível com POSIX:

if [ -z "${VAR}" ]; then
    echo "VAR is unset or set to the empty string"
fi
if [ -z "${VAR+set}" ]; then
    echo "VAR is unset"
fi
if [ -z "${VAR-unset}" ]; then
    echo "VAR is set to the empty string"
fi
if [ -n "${VAR}" ]; then
    echo "VAR is set to a non-empty string"
fi
if [ -n "${VAR+set}" ]; then
    echo "VAR is set, possibly to the empty string"
fi
if [ -n "${VAR-unset}" ]; then
    echo "VAR is either unset or set to a non-empty string"
fi

Aqui está a mesma coisa, mas em forma de tabela útil:

                        +-------+-------+-----------+
                VAR is: | unset | empty | non-empty |
+-----------------------+-------+-------+-----------+
| [ -z "${VAR}" ]       | true  | true  | false     |
| [ -z "${VAR+set}" ]   | true  | false | false     |
| [ -z "${VAR-unset}" ] | false | true  | false     |
| [ -n "${VAR}" ]       | false | false | true      |
| [ -n "${VAR+set}" ]   | false | true  | true      |
| [ -n "${VAR-unset}" ] | true  | false | true      |
+-----------------------+-------+-------+-----------+

A ${VAR+foo}construção se expande para a cadeia vazia se VARnão estiver definida ou foose VARestiver definida como algo (incluindo a cadeia vazia).

A ${VAR-foo}construção se expande para o valor de VARse definido (incluindo definido como a cadeia vazia) e foose não estiver definido . Isso é útil para fornecer padrões substituíveis pelo usuário (por exemplo, ${COLOR-red}diz para usar red, a menos que a variável COLORtenha sido definida como algo).

O motivo pelo qual [ x"${VAR}" = x ]é frequentemente recomendado para testar se uma variável está desabilitada ou definida como uma sequência vazia é porque algumas implementações do [comando (também conhecidas como test) são com erros. Se VARfor definido para algo como -n, algumas implementações farão a coisa errada quando fornecidas, [ "${VAR}" = "" ]porque o primeiro argumento para [é erroneamente interpretado como o -noperador, não uma string.

Richard Hansen
fonte
3
O teste de uma variável definida como a sequência vazia também pode ser feito usando [ -z "${VAR-set}" ].
Nwellnhof 17/05
@nwellnhof: Obrigado! Atualizei minha resposta para usar a sintaxe mais breve.
Richard Hansen
Qual é a diferença entre o primeiro e o último construto? Ambos correspondem a "VAR não está definido ou está definido como uma sequência não vazia".
Faheem Mitha
1
@FaheemMitha: Não é sua culpa - minha resposta foi difícil de ler. Eu adicionei uma tabela para espero tornar a resposta mais clara.
Richard Hansen
2
As verificações não definidas não são confiáveis. Se o usuário chamou set -uou set -o nounsetno bash, o teste resultará no erro "bash: VAR: variável não acoplada". Consulte stackoverflow.com/a/13864829 para obter uma verificação não confiável mais confiável. Meu objetivo é verificar se uma variável é nula ou não definida [ -z "${VAR:-}" ]. Minha verificação para saber se uma variável está não-vazia é [ "${VAR:-}" ].
Kevin Jin
38

-z é a melhor maneira.

Outras opções que usei é definir uma variável, mas ela pode ser substituída por outra variável, por exemplo

export PORT=${MY_PORT:-5432}

Se a $MY_PORTvariável estiver vazia, PORTserá configurada para 5432, caso contrário, PORT será definido como o valor de MY_PORT. Observe que a sintaxe inclui dois pontos e traço.

Rory
fonte
Achei isso acidentalmente hoje, e era exatamente o que eu queria. Obrigado! Eu tenho que tolerar set -o nounsetem alguns scripts.
opello
24

Se você estiver interessado em distinguir os casos de status definido como vazio e status não definido, consulte a opção -u para bash:

$ set -u
$ echo $BAR
bash: BAR: unbound variable
$ [ -z "$BAR" ] && echo true
bash: BAR: unbound variable
$ BAR=""
$ echo $BAR

$ [ -z "$BAR" ] && echo true
true
MikeyB
fonte
8

Uma alternativa que eu vi [ -z "$foo" ]é a seguinte, porém não sei por que as pessoas usam esse método, alguém sabe?

[ "x${foo}" = "x" ]

De qualquer forma, se você não permitir variáveis ​​não definidas (por set -uou set -o nounset), terá problemas com ambos os métodos. Há uma correção simples para isso:

[ -z "${foo:-}" ]

Nota: isso deixará sua variável undef.

errant.info
fonte
3
Há um comentário sobre a alternativa -zem pubs.opengroup.org/onlinepubs/009695399/utilities/test.html . Basicamente, não pretende ser uma alternativa para -z. Em vez disso, ele lida com casos em que $foopode se expandir para algo que começa com um metacaractere que [ou testseria confundido. Colocar um não metacaractere arbitrário no início elimina essa possibilidade.
James Sneeringer
6

A pergunta pergunta como verificar se uma variável é uma sequência vazia e as melhores respostas já foram dadas para isso.
Mas cheguei aqui depois de um período passado na programação em php e o que eu estava realmente procurando era uma verificação como a função vazia no php trabalhando em um shell bash.
Depois de ler as respostas, percebi que não estava pensando corretamente no bash, mas, de qualquer maneira, naquele momento, uma função como vazia no php teria sido muito útil no meu código do bash.
Como acho que isso pode acontecer com outras pessoas, decidi converter a função php empty no bash

De acordo com o manual do php :
uma variável é considerada vazia se não existir ou se seu valor for um dos seguintes:

  • "" (uma sequência vazia)
  • 0 (0 como um número inteiro)
  • 0,0 (0 como um flutuador)
  • "0" (0 como uma sequência)
  • uma matriz vazia
  • uma variável declarada, mas sem um valor

Obviamente, os casos nulos e falsos não podem ser convertidos no bash, portanto, eles são omitidos.

function empty
{
    local var="$1"

    # Return true if:
    # 1.    var is a null string ("" as empty string)
    # 2.    a non set variable is passed
    # 3.    a declared variable or array but without a value is passed
    # 4.    an empty array is passed
    if test -z "$var"
    then
        [[ $( echo "1" ) ]]
        return

    # Return true if var is zero (0 as an integer or "0" as a string)
    elif [ "$var" == 0 2> /dev/null ]
    then
        [[ $( echo "1" ) ]]
        return

    # Return true if var is 0.0 (0 as a float)
    elif [ "$var" == 0.0 2> /dev/null ]
    then
        [[ $( echo "1" ) ]]
        return
    fi

    [[ $( echo "" ) ]]
}



Exemplo de uso:

if empty "${var}"
    then
        echo "empty"
    else
        echo "not empty"
fi



Demonstração:
o seguinte trecho:

#!/bin/bash

vars=(
    ""
    0
    0.0
    "0"
    1
    "string"
    " "
)

for (( i=0; i<${#vars[@]}; i++ ))
do
    var="${vars[$i]}"

    if empty "${var}"
        then
            what="empty"
        else
            what="not empty"
    fi
    echo "VAR \"$var\" is $what"
done

exit

saídas:

VAR "" is empty
VAR "0" is empty
VAR "0.0" is empty
VAR "0" is empty
VAR "1" is not empty
VAR "string" is not empty
VAR " " is not empty

Dito isto, em uma lógica do bash, as verificações com zero nessa função podem causar problemas colaterais, qualquer pessoa que use esta função deve avaliar esse risco e talvez decidir cortar essas verificações deixando apenas a primeira.

Luca Borrione
fonte
Dentro da função empty- por que você escreveu em [[ $( echo "1" ) ]] ; returnvez de simplesmente return 1?
Dor
5

todo o if-then e -z são desnecessários.

["$ foo"] && echo "foo não está vazio"
["$ foo"] || eco "foo está realmente vazio"

fonte
3
Que irá falhar se foo contém apenas espaços
Brian
2
Também falhará em algumas conchas se foo começar com um traço, pois é interpretado como uma opção. Por exemplo, no Solaris ksh , zsh e o bash não são problema, sh e / bin / teste falhará
KTF
4

Isso é verdade exatamente quando $ FOO está definido e vazio:

[ "${FOO+x}" = x ] && [ -z "$FOO" ]

fonte
4

Pessoalmente, prefira uma maneira mais clara de verificar:

if [ "${VARIABLE}" == "" ]; then
  echo VARIABLE is empty
else
  echo VARIABLE is not empty
fi
Fedir RYKHTIK
fonte
1
Algumas conchas não aceitam o duplo sinal de igual.
Dennis Williamson
1
A pergunta era sobre bash. Estou usando o bash. Funciona bem para mim. Do que exatamente você está falando?
Fedir RYKHTIK
2
Se você estiver usando o Bash, use colchetes duplos. Meu comentário anterior foi uma simples declaração de fato para quem pode ler sua resposta e estar usando um shell diferente.
Dennis Williamson
colchetes simples estão ok neste caso, consulte serverfault.com/questions/52034/…
Luca Borrione
4

extensão oneliner da solução do duffbeer703 :

#! /bin/bash
[ -z "$1" ] || some_command_that_needs_$1_parameter
andrej
fonte
4

Meus 5 centavos: há também uma sintaxe mais curta do que if ...esta:

VALUE="${1?"Usage: $0 value"}"

Essa linha definirá VALUE se um argumento for fornecido e imprimirá uma mensagem de erro anexada com o número da linha de script em caso de erro (e encerrará a execução do script).

Outro exemplo pode ser encontrado no guia abs (procure por «Exemplo 10-7»).

gluk47
fonte
0

Não é uma resposta exata, mas ocorreu esse truque. Se a string que você procura vem de "um comando", você pode realmente armazená-lo em um ambiente. variável e, em seguida, execute-a sempre para a instrução if, então nenhum colchete é necessário!

Por exemplo, este comando, que determina se você está no debian:

grep debian /proc/version

exemplo completo:

IS_DEBIAN="grep -i debian /proc/version"

if $IS_DEBIAN; then
  echo 'yes debian'
else
  echo 'non debian'
fi

Portanto, é como uma maneira indireta (reexecutando-a sempre) para verificar se há uma sequência vazia (verifica-se a resposta a um erro do comando, mas também retorna uma sequência vazia).

rogerdpack
fonte