Como verificar se uma variável está definida no Bash?

Como sei se uma variável está definida no Bash?

Por exemplo, como verifico se o usuário deu o primeiro parâmetro para uma função?

function a {
    # if $1 is set ?
}

(Normalmente) O caminho certo

if [ -z ${var+x} ]; then echo "var is unset"; else echo "var is set to '$var'"; fi

onde ${var+x}é uma expansão de parâmetro que avalia como nada se não varestiver definida e substitui a string de xoutra forma.

Cotação Digressão

As aspas podem ser omitidas (é o que podemos dizer em ${var+x}vez de "${var+x}"), porque essa sintaxe e uso garantem que isso só será expandido para algo que não requer aspas (uma vez que se expande para x(que não contém quebras de palavras e não precisa de aspas) ou para nada (que resulta em [ -z ], que avalia convenientemente o mesmo valor (verdadeiro) que [ -z "" ]também)).

No entanto, embora as aspas possam ser omitidas com segurança, e isso não foi imediatamente óbvio para todos (nem sequer ficou claro para o primeiro autor desta explicação de citações que também é um dos principais codificadores do Bash), às vezes seria melhor escrever a solução entre aspas [ -z "${var+x}" ], pelo menor custo possível de uma penalidade de velocidade O (1). O primeiro autor também adicionou isso como um comentário ao lado do código usando esta solução, fornecendo o URL para esta resposta, que agora também inclui a explicação de por que as aspas podem ser omitidas com segurança.

(Muitas vezes) O caminho errado

if [ -z "$var" ]; then echo "var is blank"; else echo "var is set to '$var'"; fi

Isso geralmente está errado porque não faz distinção entre uma variável que está desconfigurada e uma variável que está configurada para a cadeia vazia. Ou seja, se var='', então, a solução acima produzirá "var is blank".

A distinção entre não definido e "definido para a cadeia vazia" é essencial em situações em que o usuário precisa especificar uma extensão ou lista adicional de propriedades, e que não a especificação dos padrões é um valor não vazio, enquanto a cadeia vazia deve ser especificada. faça com que o script use uma extensão vazia ou uma lista de propriedades adicionais.

A distinção pode não ser essencial em todos os cenários. Nesses casos [ -z "$var" ], tudo ficará bem.

Para verificar a variável de sequência não nula / diferente de zero, ou seja, se configurada, use

if [ -n "$1" ]

É o oposto de -z. Eu me pego usando -nmais de -z.

Você usaria como:

if [ -n "$1" ]; then
  echo "You supplied the first parameter!"
else
  echo "First parameter not supplied."
fi

Veja como testar se um parâmetro está desmarcado ou vazio ("Nulo") ou definido com um valor :

+--------------------+----------------------+-----------------+-----------------+
|   Expression       |       parameter      |     parameter   |    parameter    |
|   in script:       |   Set and Not Null   |   Set But Null  |      Unset      |
+--------------------+----------------------+-----------------+-----------------+
| ${parameter:-word} | substitute parameter | substitute word | substitute word |
| ${parameter-word}  | substitute parameter | substitute null | substitute word |
| ${parameter:=word} | substitute parameter | assign word     | assign word     |
| ${parameter=word}  | substitute parameter | substitute null | assign word     |
| ${parameter:?word} | substitute parameter | error, exit     | error, exit     |
| ${parameter?word}  | substitute parameter | substitute null | error, exit     |
| ${parameter:+word} | substitute word      | substitute null | substitute null |
| ${parameter+word}  | substitute word      | substitute word | substitute null |
+--------------------+----------------------+-----------------+-----------------+

Fonte: POSIX: Expansão do parâmetro :

Em todos os casos mostrados com "substituto", a expressão é substituída pelo valor mostrado. Em todos os casos mostrados com "assign", o parâmetro recebe esse valor, o que também substitui a expressão.

Para mostrar isso em ação:

+--------------------+----------------------+-----------------+-----------------+
|   Expression       |  FOO="world"         |     FOO=""      |    unset FOO    |
|   in script:       |  (Set and Not Null)  |  (Set But Null) |     (Unset)     |
+--------------------+----------------------+-----------------+-----------------+
| ${FOO:-hello}      | world                | hello           | hello           |
| ${FOO-hello}       | world                | ""              | hello           |
| ${FOO:=hello}      | world                | FOO=hello       | FOO=hello       |
| ${FOO=hello}       | world                | ""              | FOO=hello       |
| ${FOO:?hello}      | world                | error, exit     | error, exit     |
| ${FOO?hello}       | world                | ""              | error, exit     |
| ${FOO:+hello}      | hello                | ""              | ""              |
| ${FOO+hello}       | hello                | hello           | ""              |
+--------------------+----------------------+-----------------+-----------------+

Embora a maioria das técnicas descritas aqui esteja correta, o bash 4.2 suporta um teste real para a presença de uma variável ( man bash ), em vez de testar o valor da variável.

[[ -v foo ]]; echo $?
# 1

foo=bar
[[ -v foo ]]; echo $?
# 0

foo=""
[[ -v foo ]]; echo $?
# 0

Notavelmente, essa abordagem não causará um erro quando usada para verificar uma variável não definida no modo set -u/ set -o nounset, diferente de muitas outras abordagens, como o uso [ -z.

Existem várias maneiras de fazer isso, sendo uma delas a seguinte:

if [ -z "$1" ]

Isso será bem-sucedido se $ 1 for nulo ou não definido

Eu sempre acho a tabela POSIX na outra resposta lenta para grok, então aqui está a minha opinião:

   +----------------------+------------+-----------------------+-----------------------+
   |   if VARIABLE is:    |    set     |         empty         |        unset          |
   +----------------------+------------+-----------------------+-----------------------+
 - |  ${VARIABLE-default} | $VARIABLE  |          ""           |       "default"       |
 = |  ${VARIABLE=default} | $VARIABLE  |          ""           | $(VARIABLE="default") |
 ? |  ${VARIABLE?default} | $VARIABLE  |          ""           |       exit 127        |
 + |  ${VARIABLE+default} | "default"  |       "default"       |          ""           |
   +----------------------+------------+-----------------------+-----------------------+
:- | ${VARIABLE:-default} | $VARIABLE  |       "default"       |       "default"       |
:= | ${VARIABLE:=default} | $VARIABLE  | $(VARIABLE="default") | $(VARIABLE="default") |
:? | ${VARIABLE:?default} | $VARIABLE  |       exit 127        |       exit 127        |
:+ | ${VARIABLE:+default} | "default"  |          ""           |          ""           |
   +----------------------+------------+-----------------------+-----------------------+

Observe que cada grupo (com e sem dois pontos anteriores) tem os mesmos casos definidos e não definidos ; portanto, a única coisa que difere é como os casos vazios são tratados.

Com os dois pontos anteriores, os casos vazios e não configurados são idênticos, então eu usaria aqueles sempre que possível (ou seja :=, use , não apenas =, porque o caso vazio é inconsistente).

Cabeçalhos:

• definir meios VARIABLEnão está vazio ( VARIABLE="something")
• significa vazioVARIABLE é vazio / nulo ( VARIABLE="")
• meios VARIABLEnão definidos não existem ( unset VARIABLE)

Valores:

• $VARIABLE significa que o resultado é o valor original da variável.
• "default" significa que o resultado foi a sequência de substituição fornecida.
• "" significa que o resultado é nulo (uma sequência vazia).
• exit 127 significa que o script para de executar com o código de saída 127.
• $(VARIABLE="default")significa que o resultado é o valor original da variável e a sequência de substituição fornecida é atribuída à variável para uso futuro.

Para ver se uma variável não é vazia, eu uso

if [[ $var ]]; then ...       # `$var' expands to a nonempty string

O oposto testa se uma variável está desmarcada ou vazia:

if [[ ! $var ]]; then ...     # `$var' expands to the empty string (set or not)

Para ver se uma variável está definida (vazia ou não vazia), eu uso

if [[ ${var+x} ]]; then ...   # `var' exists (empty or nonempty)
if [[ ${1+x} ]]; then ...     # Parameter 1 exists (empty or nonempty)

O oposto testa se uma variável está desabilitada:

if [[ ! ${var+x} ]]; then ... # `var' is not set at all
if [[ ! ${1+x} ]]; then ...   # We were called with no arguments

Em uma versão moderna do Bash (4.2 ou posterior, acho; não tenho certeza), tentaria o seguinte:

if [ ! -v SOMEVARIABLE ] #note the lack of a $ sigil
then
    echo "Variable is unset"
elif [ -z "$SOMEVARIABLE" ]
then
    echo "Variable is set to an empty string"
else
    echo "Variable is set to some string"
fi

if [ "$1" != "" ]; then
  echo \$1 is set
else
  echo \$1 is not set
fi

Embora para argumentos seja normalmente melhor testar $ #, que é o número de argumentos, na minha opinião.

if [ $# -gt 0 ]; then
  echo \$1 is set
else
  echo \$1 is not set
fi

Nota

Estou dando uma resposta fortemente focada no Bash por causa da bashtag.

Resposta curta

Desde que você lide apenas com variáveis ​​nomeadas no Bash, essa função sempre deve informar se a variável foi definida, mesmo que seja uma matriz vazia.

variable-is-set() {
    declare -p "$1" &>/dev/null
}

Por que isso funciona

No Bash (pelo menos em 3.0), se varfor uma variável declarada / definida, declare -p varemite um declarecomando que definiria vara variável para qualquer que seja seu tipo e valor atuais e retorna o código de status 0(êxito). Se varnão for declarado, declare -p varemite uma mensagem de erro stderre retorna o código de status 1. Usando &>/dev/null, redireciona a saída normal stdoute a stderrsaída para /dev/null, para nunca mais ser vista, e sem alterar o código de status. Portanto, a função retorna apenas o código de status.

Por que outros métodos (às vezes) falham no Bash

• [ -n "$var" ]: Isso verifica apenas se ${var[0]}não está vazio. (No Bash, $varé o mesmo que ${var[0]}.)
• [ -n "${var+x}" ]: Apenas verifica se ${var[0]}está definido.
• [ "${#var[@]}" != 0 ]: Isso verifica apenas se pelo menos um índice de $varestá definido.

Quando este método falha no Bash

Isso só funciona para variáveis nomeadas (incluindo $_), e não determinadas variáveis especiais ( $!, $@, $#, $$, $*, $?, $-, $0, $1, $2, ..., e qualquer outro que eu possa ter esquecido). Como nenhuma dessas são matrizes, o estilo POSIX [ -n "${var+x}" ]funciona para todas essas variáveis ​​especiais. Mas tome cuidado para envolvê-lo em uma função, pois muitas variáveis ​​especiais alteram valores / existência quando funções são chamadas.

Nota de compatibilidade do shell

Se o seu script tiver matrizes e você estiver tentando torná-lo compatível com o maior número possível de shells, considere usar em typeset -pvez de declare -p. Eu li que o ksh suporta apenas o primeiro, mas não pude testar isso. Eu sei que o Bash 3.0+ e o Zsh 5.5.1 suportam ambos typeset -pe declare -p, diferindo apenas em qual é uma alternativa para o outro. Mas não testei diferenças além dessas duas palavras-chave e não testei outras conchas.

Se você precisa que seu script seja compatível com POSIX sh, não poderá usar matrizes. Sem matrizes, [ -n "{$var+x}" ]funciona.

Código de comparação para diferentes métodos no Bash

Essa função desativa a variável var, evalé o código passado, executa testes para determinar se varé definido pelo evalcódigo d e, finalmente, mostra os códigos de status resultantes para os diferentes testes.

Estou pulando test -v var, [ -v var ]e [[ -v var ]]porque eles produzem resultados idênticos ao padrão POSIX [ -n "${var+x}" ], exigindo o Bash 4.2+. Também estou pulando typeset -pporque é o mesmo que declare -pnas conchas que testei (Bash 3.0 a 5.0 e Zsh 5.5.1).

is-var-set-after() {
    # Set var by passed expression.
    unset var
    eval "$1"

    # Run the tests, in increasing order of accuracy.
    [ -n "$var" ] # (index 0 of) var is nonempty
    nonempty=$?
    [ -n "${var+x}" ] # (index 0 of) var is set, maybe empty
    plus=$?
    [ "${#var[@]}" != 0 ] # var has at least one index set, maybe empty
    count=$?
    declare -p var &>/dev/null # var has been declared (any type)
    declared=$?

    # Show test results.
    printf '%30s: %2s %2s %2s %2s\n' "$1" $nonempty $plus $count $declared
}

Código do caso de teste

Observe que os resultados do teste podem ser inesperados devido ao Bash tratar os índices não numéricos da matriz como "0" se a variável não tiver sido declarada como uma matriz associativa. Além disso, matrizes associativas são válidas apenas no Bash 4.0+.

# Header.
printf '%30s: %2s %2s %2s %2s\n' "test" '-n' '+x' '#@' '-p'
# First 5 tests: Equivalent to setting 'var=foo' because index 0 of an
# indexed array is also the nonindexed value, and non-numerical
# indices in an array not declared as associative are the same as
# index 0.
is-var-set-after "var=foo"                        #  0  0  0  0
is-var-set-after "var=(foo)"                      #  0  0  0  0
is-var-set-after "var=([0]=foo)"                  #  0  0  0  0
is-var-set-after "var=([x]=foo)"                  #  0  0  0  0
is-var-set-after "var=([y]=bar [x]=foo)"          #  0  0  0  0
# '[ -n "$var" ]' fails when var is empty.
is-var-set-after "var=''"                         #  1  0  0  0
is-var-set-after "var=([0]='')"                   #  1  0  0  0
# Indices other than 0 are not detected by '[ -n "$var" ]' or by
# '[ -n "${var+x}" ]'.
is-var-set-after "var=([1]='')"                   #  1  1  0  0
is-var-set-after "var=([1]=foo)"                  #  1  1  0  0
is-var-set-after "declare -A var; var=([x]=foo)"  #  1  1  0  0
# Empty arrays are only detected by 'declare -p'.
is-var-set-after "var=()"                         #  1  1  1  0
is-var-set-after "declare -a var"                 #  1  1  1  0
is-var-set-after "declare -A var"                 #  1  1  1  0
# If 'var' is unset, then it even fails the 'declare -p var' test.
is-var-set-after "unset var"                      #  1  1  1  1

Saída de teste

As mnemónicas teste na linha de cabeçalho correspondem a [ -n "$var" ], [ -n "${var+x}" ], [ "${#var[@]}" != 0 ], e declare -p var, respectivamente.

                         test: -n +x #@ -p
                      var=foo:  0  0  0  0
                    var=(foo):  0  0  0  0
                var=([0]=foo):  0  0  0  0
                var=([x]=foo):  0  0  0  0
        var=([y]=bar [x]=foo):  0  0  0  0
                       var='':  1  0  0  0
                 var=([0]=''):  1  0  0  0
                 var=([1]=''):  1  1  0  0
                var=([1]=foo):  1  1  0  0
declare -A var; var=([x]=foo):  1  1  0  0
                       var=():  1  1  1  0
               declare -a var:  1  1  1  0
               declare -A var:  1  1  1  0
                    unset var:  1  1  1  1

Sumário

• declare -p var &>/dev/null é (100%?) confiável para testar variáveis ​​nomeadas no Bash desde pelo menos 3,0.
• [ -n "${var+x}" ] é confiável em situações compatíveis com POSIX, mas não pode manipular matrizes.
• Existem outros testes para verificar se uma variável não é vazia e para verificar variáveis ​​declaradas em outros shells. Mas esses testes não são adequados para scripts Bash nem POSIX.

Para aqueles que procuram verificar se não estão definidos ou vazios quando em um script com set -u:

if [ -z "${var-}" ]; then
   echo "Must provide var environment variable. Exiting...."
   exit 1
fi

A [ -z "$var" ]verificação regular falhará com var; unbound variableif, set -umas se [ -z "${var-}" ] expandirá para a string vazia, se varestiver desativada sem falha.

Você quer sair se não estiver definido

Isso funcionou para mim. Eu queria que meu script saísse com uma mensagem de erro se um parâmetro não estivesse definido.

#!/usr/bin/env bash

set -o errexit

# Get the value and empty validation check all in one
VER="${1:?You must pass a version of the format 0.0.0 as the only argument}"

Isso retorna com um erro quando é executado

peek@peek:~$ ./setver.sh
./setver.sh: line 13: 1: You must pass a version of the format 0.0.0 as the only argument

Marque apenas, sem saída - Vazio e Desativado são INVÁLIDOS

Tente esta opção se você quiser apenas verificar se o valor configurado = VALID ou não configurado / vazio = INVALID.

TSET="good val"
TEMPTY=""
unset TUNSET

if [ "${TSET:-}" ]; then echo "VALID"; else echo "INVALID";fi
# VALID
if [ "${TEMPTY:-}" ]; then echo "VALID"; else echo "INVALID";fi
# INVALID
if [ "${TUNSET:-}" ]; then echo "VALID"; else echo "INVALID";fi
# INVALID

Ou, mesmo testes breves ;-)

[ "${TSET:-}"   ] && echo "VALID" || echo "INVALID"
[ "${TEMPTY:-}" ] && echo "VALID" || echo "INVALID"
[ "${TUNSET:-}" ] && echo "VALID" || echo "INVALID"

Marque apenas, sem saída - Somente vazio é INVÁLIDO

E esta é a resposta para a pergunta. Use isso se você quiser apenas verificar se o valor definido / vazio = VÁLIDO ou não definido = INVÁLIDO.

OBSERVAÇÃO, o "1" em "..- 1}" é insignificante, pode ser qualquer coisa (como x)

TSET="good val"
TEMPTY=""
unset TUNSET

if [ "${TSET+1}" ]; then echo "VALID"; else echo "INVALID";fi
# VALID
if [ "${TEMPTY+1}" ]; then echo "VALID"; else echo "INVALID";fi
# VALID
if [ "${TUNSET+1}" ]; then echo "VALID"; else echo "INVALID";fi
# INVALID

Testes curtos

[ "${TSET+1}"   ] && echo "VALID" || echo "INVALID"
[ "${TEMPTY+1}" ] && echo "VALID" || echo "INVALID"
[ "${TUNSET+1}" ] && echo "VALID" || echo "INVALID"

Dedico esta resposta a @ mklement0 (comentários) que me desafiou a responder à pergunta com precisão.

Referência http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_02

Para verificar se uma variável está configurada com um valor não vazio, use [ -n "$x" ], como outros já indicaram.

Na maioria das vezes, é uma boa idéia tratar uma variável que tenha um valor vazio da mesma maneira que uma variável que não esteja definida. Mas você pode distinguir os dois se precisar: [ -n "${x+set}" ]( "${x+set}"expande para setse xestiver definido e para a sequência vazia, se xnão estiver definido ).

Para verificar se um parâmetro foi aprovado, teste $#, que é o número de parâmetros passados ​​para a função (ou para o script, quando não estiver em uma função) (consulte a resposta de Paulo ).

Leia a seção "Expansão de parâmetros" da bashpágina de manual. A expansão de parâmetro não fornece um teste geral para uma variável que está sendo definida, mas há várias coisas que você pode fazer em um parâmetro, se não estiver definido.

Por exemplo:

function a {
    first_arg=${1-foo}
    # rest of the function
}

será first_argigual a $1se for atribuído, caso contrário, ele usará o valor "foo". Se aabsolutamente for necessário usar um único parâmetro e não existir um bom padrão, você poderá sair com uma mensagem de erro quando nenhum parâmetro for fornecido:

function a {
    : ${1?a must take a single argument}
    # rest of the function
}

(Observe o uso de :como um comando nulo, que apenas expande os valores de seus argumentos. Não queremos fazer nada $1neste exemplo, basta sair se não estiver definido)

No bash, você pode usar -vdentro do [[ ]]built-in:

#! /bin/bash -u

if [[ ! -v SOMEVAR ]]; then
    SOMEVAR='hello'
fi

echo $SOMEVAR

Usar [[ -z "$var" ]]é a maneira mais fácil de saber se uma variável foi configurada ou não, mas essa opção -znão faz distinção entre uma variável não configurada e uma variável definida como uma sequência vazia:

$ set=''
$ [[ -z "$set" ]] && echo "Set" || echo "Unset" 
Unset
$ [[ -z "$unset" ]] && echo "Set" || echo "Unset"
Unset

É melhor checá-lo de acordo com o tipo de variável: variável env, parâmetro ou variável regular.

Para uma variável env:

[[ $(env | grep "varname=" | wc -l) -eq 1 ]] && echo "Set" || echo "Unset"

Para um parâmetro (por exemplo, para verificar a existência do parâmetro $5):

[[ $# -ge 5 ]] && echo "Set" || echo "Unset"

Para uma variável regular (usando uma função auxiliar, para fazê-lo de maneira elegante):

function declare_var {
   declare -p "$1" &> /dev/null
}
declare_var "var_name" && echo "Set" || echo "Unset"

Notas:

• $#: fornece o número de parâmetros posicionais.
• declare -p: fornece a definição da variável passada como parâmetro. Se existir, retorna 0, se não, retorna 1 e imprime uma mensagem de erro.
• &> /dev/null: suprime a saída declare -psem afetar seu código de retorno.

As respostas acima não funcionam quando a opção Bash set -uestá ativada. Além disso, eles não são dinâmicos, por exemplo, como testar a variável com o nome "dummy" definido? Tente o seguinte:

is_var_defined()
{
    if [ $# -ne 1 ]
    then
        echo "Expected exactly one argument: variable name as string, e.g., 'my_var'"
        exit 1
    fi
    # Tricky.  Since Bash option 'set -u' may be enabled, we cannot directly test if a variable
    # is defined with this construct: [ ! -z "$var" ].  Instead, we must use default value
    # substitution with this construct: [ ! -z "${var:-}" ].  Normally, a default value follows the
    # operator ':-', but here we leave it blank for empty (null) string.  Finally, we need to
    # substitute the text from $1 as 'var'.  This is not allowed directly in Bash with this
    # construct: [ ! -z "${$1:-}" ].  We need to use indirection with eval operator.
    # Example: $1="var"
    # Expansion for eval operator: "[ ! -z \${$1:-} ]" -> "[ ! -z \${var:-} ]"
    # Code  execute: [ ! -z ${var:-} ]
    eval "[ ! -z \${$1:-} ]"
    return $?  # Pedantic.
}

Relacionado: No Bash, como faço para testar se uma variável está definida no modo "-u"

Você pode fazer:

function a {
        if [ ! -z "$1" ]; then
                echo '$1 is set'
        fi
}

Minha maneira preferida é esta:

$ var=10
$ if ! ${var+false};then echo "is set";else echo "NOT set";fi
is set
$ unset -v var
$ if ! ${var+false};then echo "is set";else echo "NOT set";fi
NOT set

Então, basicamente, se uma variável é definida, ela se torna "uma negação do resultado false" (o que será true= "está definido").

E, se não estiver definido, ele se tornará "uma negação do resultado true" (conforme o resultado vazio for avaliado true) (assim terminará como sendo false= "NÃO definido").

[[ $foo ]]

Ou

(( ${#foo} ))

Ou

let ${#foo}

Ou

declare -p foo

Em um shell, você pode usar o -zoperador True, se o comprimento da string for zero.

Um one-liner simples para definir o padrão, MY_VARse não estiver definido, caso contrário, opcionalmente, você pode exibir a mensagem:

[[ -z "$MY_VAR" ]] && MY_VAR="default"
[[ -z "$MY_VAR" ]] && MY_VAR="default" || echo "Variable already set."

if [[ ${1:+isset} ]]
then echo "It was set and not null." >&2
else echo "It was not set or it was null." >&2
fi

if [[ ${1+isset} ]]
then echo "It was set but might be null." >&2
else echo "It was was not set." >&2
fi

Encontrei um código (muito) melhor para fazer isso, se você quiser verificar alguma coisa $@.

se [[$ 1 = ""]]
então
  eco '$ 1 está em branco'
outro
  eco '$ 1 está preenchido'
fi

Por que isso tudo? Tudo $@existe no Bash, mas, por padrão, está em branco, test -ze test -nnão pode ajudá-lo.

Atualização: Você também pode contar o número de caracteres em um parâmetro.

se [$ {# 1} = 0]
então
  eco '$ 1 está em branco'
outro
  eco '$ 1 está preenchido'
fi

if [[ ${!xx[@]} ]] ; then echo xx is defined; fi

É isso que eu uso todos os dias:

#
# Check if a variable is set
#   param1  name of the variable
#
function is_set()
{
    [[ -n "${1}" ]] && test -n "$(eval "echo "\${${1}+x}"")"
}

Isso funciona bem no Linux e Solaris até o bash 3.0.

bash-3.00$ myvar="TEST"
bash-3.00$ is_set myvar ; echo $?
0
bash-3.00$ mavar=""
bash-3.00$ is_set myvar ; echo $?
0
bash-3.00$ unset myvar
bash-3.00$ is_set myvar ; echo $?
1

Eu gosto de funções auxiliares para esconder os detalhes brutos do bash. Nesse caso, fazer isso adiciona ainda mais grossura (oculta):

# The first ! negates the result (can't use -n to achieve this)
# the second ! expands the content of varname (can't do ${$varname})
function IsDeclared_Tricky
{
  local varname="$1"
  ! [ -z ${!varname+x} ]
}

Como tive bugs pela primeira vez nesta implementação (inspirada nas respostas de Jens e Lionel), criei uma solução diferente:

# Ask for the properties of the variable - fails if not declared
function IsDeclared()
{
  declare -p $1 &>/dev/null
}

Acho que é mais direto, mais bash e mais fácil de entender / lembrar. O caso de teste mostra que é equivalente:

function main()
{
  declare -i xyz
  local foo
  local bar=
  local baz=''

  IsDeclared_Tricky xyz; echo "IsDeclared_Tricky xyz: $?"
  IsDeclared_Tricky foo; echo "IsDeclared_Tricky foo: $?"
  IsDeclared_Tricky bar; echo "IsDeclared_Tricky bar: $?"
  IsDeclared_Tricky baz; echo "IsDeclared_Tricky baz: $?"

  IsDeclared xyz; echo "IsDeclared xyz: $?"
  IsDeclared foo; echo "IsDeclared foo: $?"
  IsDeclared bar; echo "IsDeclared bar: $?"
  IsDeclared baz; echo "IsDeclared baz: $?"
}

main

O caso de teste, também mostra que local varnão NÃO declaram var (a não ser seguido por '='). Por algum tempo, pensei em declarar variáveis ​​dessa maneira, apenas para descobrir agora que apenas expressei minha intenção ... Acho que não é uma operação.

IsDeclared_Tricky xyz: 1
foo IsDeclared_Tricky: 1
IsDeclared_Tricky bar: 0
IsDeclared_Tricky baz: 0
IsDeclared xyz: 1
foo IsDeclared: 1
bar IsDeclared: 0
baz IsDeclared: 0

BÔNUS: caso de uso

Eu principalmente uso esse teste para fornecer (e retornar) parâmetros para funções de uma maneira um pouco "elegante" e segura (quase semelhante a uma interface ...):

#auxiliary functions
function die()
{
  echo "Error: $1"; exit 1
}

function assertVariableDeclared()
{
  IsDeclared "$1" || die "variable not declared: $1"
}

function expectVariables()
{
  while (( $# > 0 )); do
    assertVariableDeclared $1; shift
  done
}

# actual example
function exampleFunction()
{
  expectVariables inputStr outputStr
  outputStr="$inputStr world!"
}

function bonus()
{
  local inputStr='Hello'
  local outputStr= # remove this to trigger error
  exampleFunction
  echo $outputStr
}

bonus

Se chamado com all requer variáveis ​​declaradas:

Olá Mundo!

outro:

Erro: variável não declarada: outputStr

Depois de examinar todas as respostas, isso também funciona:

if [[ -z $SOME_VAR ]]; then read -p "Enter a value for SOME_VAR: " SOME_VAR; fi
echo "SOME_VAR=$SOME_VAR"

se você não colocar no SOME_VARlugar do que eu tenho $SOME_VAR, será definido como um valor vazio; $é necessário para que isso funcione.

Sumário

• Use test -n "${var-}"para verificar se a variável não está vazia (e, portanto, também deve ser definida / definida)
• Use test ! -z "${var+}"para verificar se a variável está definida / definida (mesmo que esteja vazia)

Observe que o primeiro caso de uso é muito mais comum em scripts de shell e é isso que você geralmente desejará usar.

Notas

• Esta solução deve funcionar em todos os shells POSIX (sh, bash, zsh, ksh, dash)
• Algumas das outras respostas para esta pergunta estão corretas, mas podem ser confusas para pessoas inexperientes em scripts de shell, então eu queria fornecer uma resposta TLDR que seja menos confusa para essas pessoas.

Explicação

Para entender como essa solução funciona, você precisa entender o comando POSIXtest e a expansão dos parâmetros do shell POSIX ( spec ), portanto, vamos cobrir o básico absoluto necessário para entender a resposta.

O comando test avalia uma expressão e retorna verdadeiro ou falso (por meio do status de saída). O operador -nretornará true se o operando for uma sequência não vazia. Por exemplo, test -n "a"retorna true, enquanto test -n ""retorna false. Agora, para verificar se uma variável não está vazia (o que significa que deve ser definida), você pode usar test -n "$var". No entanto, alguns scripts de shell têm uma opção set ( set -u) que faz com que qualquer referência a variáveis ​​indefinidas emita um erro; portanto, se a variável varnão estiver definida, a expressão $acausará um erro. Para lidar com esse caso corretamente, você deve usar a expansão de variável, que informará o shell para substituir a variável por uma sequência alternativa, se não estiver definida, evitando o erro mencionado acima.

A expansão da variável ${var-}significa: se a variável não varestiver definida (também chamada de "não definida"), substitua-a por uma sequência vazia. Portanto test -n "${var-}", retornará true se $varnão estiver vazio, o que quase sempre é o que você deseja verificar nos scripts de shell. A verificação inversa, se $varfor indefinida ou vazia, seria test -z "${var-}".

Agora, para o segundo caso de uso: verificando se a variável varestá definida, vazia ou não. Este é um caso de uso menos comum e um pouco mais complexo, e eu aconselho você a ler a ótima resposta de Lionels para entendê-la melhor.

Para verificar se um var está definido ou não

var=""; [[ $var ]] && echo "set" || echo "not set"

Se você deseja testar se uma variável está vinculada ou não, isso funciona bem, mesmo depois de ativar a opção de conjunto de substantivos:

set -o noun set

if printenv variableName >/dev/null; then
    # variable is bound to a value
else
    # variable is unbound
fi