Para verificar se existe uma variável de cadeia não nula/ não nula, ou seja, se estiver definida, utilizar

if [ -n "$1" ]

Aqui está como testar se um parâmetro é desactivado , ou vazio ("nulo") ou definido com um valor:

+--------------------+----------------------+-----------------+-----------------+
|                    |       parameter      |     parameter   |    parameter    |
|                    |   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 apresentados com "Substituto", a expressão é substituída pelo valor indicado. Em todos os casos mostrados com "assign", parâmetro é atribuído esse valor, que também substitui a expressão.

Há muitas maneiras de fazer isto com o seguinte sendo um deles:

if [ -z "$1" ]

Isto tem sucesso se $1 for nulo ou desactivado

Enquanto a maioria das técnicas aqui indicados estão correctos, 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

Para ver se uma variável não está vazia, Eu uso

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

Os testes opostos se uma variável estiver desligada 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)

Os testes opostos se uma variável estiver desligada:

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

Encontro sempre a mesa POSIX na outra resposta lenta para grok, por isso 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"  |          ""           |          ""           |
   +----------------------+------------+-----------------------+-----------------------+

Note que cada grupo (com e sem dois pontos anteriores) tem o mesmo conjunto e os estojos, de modo que a única coisa que difere é como os vazios são tratados.

Com o cólon anterior, os casos vazios e desactivados são idênticos, por isso eu usaria aqueles sempre que possível( isto é, usar :=, não apenas =, porque o caso vazio é inconsistente).

Rubricas:

• Conjunto significa que VARIABLE não está vazio (VARIABLE="something")
• vazio significa VARIABLE vazio/nulo (VARIABLE="")
• desactivado significa que VARIABLE não existe (unset VARIABLE)

Valores:

• $VARIABLE significa que o resultado é o valor original da variável.
• "default" significa que o resultado foi a cadeia de substituição fornecido.
• "" significa que o resultado é nulo (um texto vazio).
• exit 127 significa que o programa pára de ser executado com o código de saída 127.
• $(VARIABLE="default") significa que o resultado é o valor original da variável e a cadeia de substituição fornecida é atribuída à variável para utilização futura.

Em uma versão moderna de Bash (4.2 ou mais tarde eu penso; eu não sei ao certo), eu tentaria isto:

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 é 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

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

Por exemplo:

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

Será igual a first_arg Se for atribuído, caso contrário usa o valor "foo". Se a tiver absolutamente de tomar um único parâmetro, e não existir um bom padrão, poderá sair com uma mensagem de erro quando não existir nenhum parâmetro dado:

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

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

Queres sair se estiver desligado

#!/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}"

Isto devolve 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

Verifique apenas, nenhuma saída-vazia e desactivada são inválidas {[[8]}

Tente esta opção se apenas quiser verificar se o valor definido=válido ou desactivado/vazio=inválido.

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 curtos; -)

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

Verifique apenas, nenhuma saída-apenas vazio é Inválido

Nota, o " 1 "em"..- "É 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"

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

Para verificar se uma variável está definida com um valor não-vazio, use {[[0]}, como outros já indicaram.

Na maioria das vezes, é uma boa ideia tratar uma variável que tem um valor vazio da mesma forma que uma variável que está desactivada. Mas podes distinguir os dois se precisares.: [ -n "${x+set}" ] ("${x+set}" expande para set Se x está definido e para o texto vazio se x está desactivado).

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

Na bash pode usar -v dentro do [[ ]] Edifício:

#! /bin/bash -u

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

echo $SOMEVAR

Para aqueles que procuram verificar se estão desligados ou vazios quando num programa com set -u:

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

A verificação regular [ -z "$var" ] falhará com var; unbound variable se set -u mas [ -z "${var-}" ] expande para um texto vazio se var estiver desactivado sem falhar.

Podes fazer:

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

As respostas acima não funcionam quando a opção Bash set -u está activa. Além disso, eles não são dinâmicos, por exemplo, como testar é variável com o nome de "manequim" é definido? Tenta isto.

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: na Bash, como testar se uma variável é definida no modo "-u"

Usar [[ -z "$var" ]] é a maneira mais fácil de saber se uma variável foi definida ou não, mas essa opção -z não distingue entre uma variável desactivada e uma variável configurada para um texto vazio:

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

É melhor verificar 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 (utilizando um auxiliar função, para fazê-lo de uma forma elegante):

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

Notas:

• $#: diz que o número de parâmetros posicionais.
• declare -p: dá-Lhe a definição da variável passada como parâmetro. Se existir, devolve 0, se não, devolve 1 e imprime uma mensagem de erro.
• $?: dá-lhe o código de Estado do último comando executado.

Numa linha de comandos pode usar o operador -z que é verdadeiro se o comprimento do texto for zero.

Uma linha simples para definir o valor por omissão MY_VAR Se não estiver definido, caso contrário, opcionalmente, poderá mostrar a mensagem:

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

A minha maneira preferida é esta:

$var=10
$if ! ${var+false};then echo "is set";else echo "NOT set";fi
is set
$unset 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 resultante false "(o que será true = "é definido").

E, se estiver desactivado, tornar-se-á" uma negação do resultante true "(como o resultado vazio avalia true) (assim terminará como sendo false = "não definido").

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

Eu encontrei um (muito) Código melhor para fazer isso se você quiser verificar para qualquer coisa em {[[2]}.

if [[ $1 = "" ]]
then
  echo '$1 is blank'
else
  echo '$1 is filled up'
fi

Update: Você também pode contar o número de caracteres em um Parâmetros.

if [ ${#1} = 0 ]
then
  echo '$1 is blank'
else
  echo '$1 is filled up'
fi

[[ $foo ]]

Ou

(( ${#foo} ))

Ou

let ${#foo}

Ou

declare -p foo

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

Eu sempre uso este, baseado no fato de que parece fácil de ser entendido por qualquer um que vê o Código pela primeira vez:

if [ "$variable" = "" ]
    then
    echo "Variable X is empty"
fi

E, se quiser verificar se não está vazio,

if [ ! "$variable" = "" ]
    then
    echo "Variable X is not empty"
fi

Isto é o 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}"")"
}

Isto funciona bem no Linux e no Solaris até ao 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

SE var pode ser um array, então [ -z "${var+x}" ] Substituição de Parâmetros está incorrecta. Para ter a certeza absoluta na Bash, precisa de usar a sintaxe array como [ "${#var[@]}" = 0 ], Como mostrado em baixo.

is-var-set () {
    results="\${var+x}=${var+x}\t\${#var[@]}=${#var[@]}"
    if [ -z "${var+x}" ] && [ "${#var[@]}" = 0 ]; then
        echo -e "$1: var's unset.\t$results"
    elif [ -n "${var+x}" ] && [ "${#var[@]}" != 0 ]; then
        echo -e "$1: var is set. \t$results"
    else
        echo -e "$1: Is var set? \t$results"
    fi
    unset var # so we don't have to do it everywhere else
}

unset var;      is-var-set 1 # var unset
var='';         is-var-set 2 # var[0] set to ''
var=foo;        is-var-set 3 # var[0] set to 'foo'
var=();         is-var-set 4 # var unset (all indices)
var=(foo);      is-var-set 5 # var[0] set to 'foo'
var=([0]=foo);  is-var-set 6 # var[0] set to 'foo'
var=([1]=foo);  is-var-set 7 # var[0] unset, but var[1] set to 'foo'
declare -a var; is-var-set 8 # var empty, but declared as an array
declare -A var; is-var-set 9 # var empty, but declared as an associative array
declare -A var  # Because is-var-set() conveniently unsets it
var=([xz]=foo); is-var-set A # var[xz] set to 'foo', but var's otherwise empty
declare -a var  # Demonstrate that Bash knows about var, even when there's
declare -A var; is-var-set B # apparently no way to just _check_ its existence

1: var's unset. ${var+x}=       ${#var[@]}=0
2: var is set.  ${var+x}=x      ${#var[@]}=1
3: var is set.  ${var+x}=x      ${#var[@]}=1
4: var's unset. ${var+x}=       ${#var[@]}=0
5: var is set.  ${var+x}=x      ${#var[@]}=1
6: var is set.  ${var+x}=x      ${#var[@]}=1
7: Is var set?  ${var+x}=       ${#var[@]}=1
8: var's unset. ${var+x}=       ${#var[@]}=0
9: var's unset. ${var+x}=       ${#var[@]}=0
A: Is var set?  ${var+x}=       ${#var[@]}=1
./foo.sh: line 26: declare: var: cannot convert indexed to associative array
B: var's unset. ${var+x}=       ${#var[@]}=0

Em suma:

• ${var+x} parameter expansion syntax works just as well as ${#var[@]} array syntax in most cases, such as checking parameters to functions. A única maneira que este caso poderia quebrar é se uma versão futura do Bash adiciona uma maneira de passar arrays para funções sem Converter conteúdo para argumentos individuais.
• a sintaxe do Array é necessária para não estar vazia arrays (associativos ou não) com o elemento 0 desactivado.
• nenhuma sintaxe explica o que se passa se declare -a var foi usado sem atribuir um valor nulo algures na matriz. Bash ainda distingue o caso em algum lugar (como visto no teste B acima), então esta resposta não é infalível. Felizmente Bash converte variáveis de ambiente exportadas em strings ao executar um programa/ script, de modo que quaisquer problemas com as variáveis declaradas-mas-desactivadas serão contidos em um único script, pelo menos se não é buscar outros guiões.

Se quiser testar se uma variável está ligada ou não, isto funciona bem, mesmo depois de ter ligado a opção do substantivo:

set -o noun set

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

# 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} ]
}

Porque eu tive erros pela primeira vez nesta implementação (inspirado pelas respostas de Jens e Lionel), eu cheguei a uma solução diferente:

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

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 estojo de ensaio também mostra que local var não declarar var (excepto se seguido de"="). Durante algum tempo, pensei ter declarado variáveis desta forma, só para descobrir agora que apenas expressei a minha intenção... Acho que não deu em nada.

IsDeclared_Tricky xyz: 1
Isdeclared_ dicky foo: 1
Isdeclared_ dicky bar: 0
IsDeclared_Tricky baz: 0
Xyz IsDeclared: 1
Foo IsDeclared: 1
Barra IsDeclared: 0
Baz IsDeclared: 0

Bônus: usecase

#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 todas as variáveis requer declaração:

Olá, mundo!

Else:

Erro: variável não declarada: outputStr

Funções para verificar se a variável é declarada / desactivada

Incluindo vazio $array=()

O seguinte teste de funções se o nome próprio existe como uma variável

# The first parameter needs to be the name of the variable to be checked.
# (See example below)

var_is_declared() {
    { [[ -n ${!1+anything} ]] || declare -p $1 &>/dev/null;}
}

var_is_unset() {
    { [[ -z ${!1+anything} ]] && ! declare -p $1 &>/dev/null;} 
}

• por primeiro teste se a variável for (un)definida, a chamada a declarar pode ser evitada, se não for necessário.
• se no entanto $1 contiver o nome de um $array=() vazio, a chamada a declarar certificar-se-á de que obtemos o resultado certo
• nunca há muitos dados passados para /dev / null como declarar só é chamado se a variável for desativada ou uma matriz vazia.

Estas funções testariam como demonstrado nas seguintes condições:

a;       # is not declared
a=;      # is declared
a="foo"; # is declared
a=();    # is declared
a=("");  # is declared
unset a; # is not declared

a;       # is unset
a=;      # is not unset
a="foo"; # is not unset
a=();    # is not unset
a=("");  # is not unset
unset a; # is unset

.

Para mais detalhes

E um script de teste Veja a minha resposta à pergunta "Como posso verificar se existe uma variável na bash?".

observação: o uso semelhante de declare -p, como também é mostrado por peregrinando-lk ' s a resposta, é verdadeiramente coincidência. Caso contrário, eu teria creditado!

case "$1" in
 "") echo "blank";;
 *) echo "set"
esac