O que é uma maneira concisa de verificar se as variáveis ​​de ambiente estão definidas em um script de shell Unix?

Eu tenho alguns scripts shell do Unix nos quais preciso verificar se certas variáveis ​​de ambiente estão definidas antes de começar a fazer as coisas, então faço esse tipo de coisa:

if [ -z "$STATE" ]; then
    echo "Need to set STATE"
    exit 1
fi  

if [ -z "$DEST" ]; then
    echo "Need to set DEST"
    exit 1
fi

que é muita digitação. Existe um idioma mais elegante para verificar se um conjunto de variáveis ​​de ambiente está definido?

Edição: devo mencionar que essas variáveis ​​não têm valor padrão significativo - o script deve errar se houver algum não definido.

Expansão de parâmetros

A resposta óbvia é usar uma das formas especiais de expansão de parâmetros:

: ${STATE?"Need to set STATE"}
: ${DEST:?"Need to set DEST non-empty"}

Ou melhor (consulte a seção 'Posição das aspas duplas' abaixo):

: "${STATE?Need to set STATE}"
: "${DEST:?Need to set DEST non-empty}"

A primeira variante (usando just ?) requer que STATE seja definido, mas STATE = "" (uma sequência vazia) está OK - não exatamente o que você deseja, mas a notação alternativa e antiga.

A segunda variante (usando :?) requer que DEST seja definido e não esteja vazio.

Se você não fornecer nenhuma mensagem, o shell fornecerá uma mensagem padrão.

A ${var?}construção é portátil de volta à Versão 7 UNIX e ao Bourne Shell (1978 ou nos próximos anos). A ${var:?}construção é um pouco mais recente: acho que estava no System III UNIX por volta de 1981, mas pode ter sido no PWB UNIX antes disso. Está, portanto, no Korn Shell e nos shells POSIX, incluindo especificamente o Bash.

Geralmente é documentado na página de manual do shell em uma seção chamada Expansão de parâmetros . Por exemplo, o bashmanual diz:

${parameter:?word}

Exibir erro se nulo ou não definido. Se o parâmetro for nulo ou não definido, a expansão da palavra (ou uma mensagem nesse sentido se a palavra não estiver presente) será gravada no erro padrão e o shell, se não for interativo, será encerrado. Caso contrário, o valor do parâmetro é substituído.

O comando do cólon

Provavelmente devo acrescentar que o comando dois pontos simplesmente tem seus argumentos avaliados e depois é bem-sucedido. É a notação de comentário do shell original (antes de ' #' até o final da linha). Por um longo tempo, os scripts de shell Bourne tiveram dois pontos como o primeiro caractere. O Shell C leria um script e usaria o primeiro caractere para determinar se era para o Shell C (um #hash ' ') ou o shell Bourne ( :dois pontos ' '). Então o kernel entrou em ação e adicionou suporte aos comentários ' #!/path/to/program' e o shell Bourne recebeu ' #', e a convenção do cólon foi esquecida. Mas se você encontrar um script que comece com dois pontos, agora saberá o porquê.

Posição de aspas duplas

blong perguntou em um comentário :

Alguma opinião sobre essa discussão? https://github.com/koalaman/shellcheck/issues/380#issuecomment-145872749

A essência da discussão é:

… No entanto, quando eu shellcheck(com a versão 0.4.1), recebo esta mensagem:

In script.sh line 13:
: ${FOO:?"The environment variable 'FOO' must be set and non-empty"}
  ^-- SC2086: Double quote to prevent globbing and word splitting.

Algum conselho sobre o que devo fazer neste caso?

A resposta curta é "faça o que shellchecksugere":

: "${STATE?Need to set STATE}"
: "${DEST:?Need to set DEST non-empty}"

Para ilustrar o motivo, estude o seguinte. Observe que o :comando não ecoa seus argumentos (mas o shell avalia os argumentos). Queremos ver os argumentos, portanto, o código abaixo usa printf "%s\n"no lugar de :.

$ mkdir junk
$ cd junk
$ > abc
$ > def
$ > ghi
$ 
$ x="*"
$ printf "%s\n" ${x:?You must set x}    # Careless; not recommended
abc
def
ghi
$ unset x
$ printf "%s\n" ${x:?You must set x}    # Careless; not recommended
bash: x: You must set x
$ printf "%s\n" "${x:?You must set x}"  # Careful: should be used
bash: x: You must set x
$ x="*"
$ printf "%s\n" "${x:?You must set x}"  # Careful: should be used
*
$ printf "%s\n" ${x:?"You must set x"}  # Not quite careful enough
abc
def
ghi
$ x=
$ printf "%s\n" ${x:?"You must set x"}  # Not quite careful enough
bash: x: You must set x
$ unset x
$ printf "%s\n" ${x:?"You must set x"}  # Not quite careful enough
bash: x: You must set x
$ 

Observe como o valor em $xé expandido para primeiro *e depois para uma lista de nomes de arquivos quando a expressão geral não está entre aspas duplas. Isto é o que shellcheckestá recomendando que deve ser corrigido. Não verifiquei que ela não se opõe ao formulário em que a expressão está entre aspas duplas, mas é uma suposição razoável de que estaria tudo bem.

Tente o seguinte:

[ -z "$STATE" ] && echo "Need to set STATE" && exit 1;

Sua pergunta depende do shell que você está usando.

A casca de Bourne deixa muito pouco no que você procura.

MAS...

Funciona, em quase todos os lugares.

Apenas tente ficar longe do csh. Foi bom para os sinos e assobios que adicionou, comparou a concha Bourne, mas está realmente rangendo agora. Se você não acredita em mim, tente separar o STDERR no csh! (-:

Existem duas possibilidades aqui. O exemplo acima, ou seja, usando:

${MyVariable:=SomeDefault}

pela primeira vez, você precisa se referir a $ MyVariable. Isso leva o env. var MyVariable e, se não estiver definido no momento, atribui o valor de SomeDefault à variável para uso posterior.

Você também tem a possibilidade de:

${MyVariable:-SomeDefault}

que apenas substitui SomeDefault pela variável em que você está usando essa construção. Ele não atribui o valor SomeDefault à variável, e o valor de MyVariable ainda será nulo depois que essa instrução for encontrada.

Certamente, a abordagem mais simples é adicionar a -uopção ao shebang (a linha na parte superior do seu script), supondo que você esteja usando bash:

#!/bin/sh -u

Isso fará com que o script saia se houver alguma variável não acoplada oculta.

${MyVariable:=SomeDefault}

Se MyVariablefor definido e não nulo, redefinirá o valor da variável (= nada acontece).
Senão, MyVariableestá definido como SomeDefault.

O acima tentará executar ${MyVariable}, portanto, se você quiser apenas definir a variável, faça:

MyVariable=${MyVariable:=SomeDefault}

Na minha opinião, a verificação mais simples e mais compatível para #! / Bin / sh é:

if [ "$MYVAR" = "" ]
then
   echo "Does not exist"
else
   echo "Exists"
fi

Novamente, isso é para / bin / sh e também é compatível com sistemas Solaris antigos.

bash4.2 introduziu o -voperador que testa se um nome está definido com algum valor, mesmo a string vazia.

$ unset a
$ b=
$ c=
$ [[ -v a ]] && echo "a is set"
$ [[ -v b ]] && echo "b is set"
b is set
$ [[ -v c ]] && echo "c is set"
c is set

Eu sempre usei:

if [ "x$STATE" == "x" ]; then echo "Need to set State"; exit 1; fi

Receio que não seja muito mais conciso.

Sob CSH, você tem $? STATE.

Para futuras pessoas como eu, eu queria dar um passo adiante e parametrizar o nome do var, para que eu possa percorrer uma lista de nomes de variáveis ​​com tamanho variável:

#!/bin/bash
declare -a vars=(NAME GITLAB_URL GITLAB_TOKEN)

for var_name in "${vars[@]}"
do
  if [ -z "$(eval "echo \$$var_name")" ]; then
    echo "Missing environment variable $var_name"
    exit 1
  fi
done

Podemos escrever uma boa asserção para verificar várias variáveis ​​de uma só vez:

#
# assert if variables are set (to a non-empty string)
# if any variable is not set, exit 1 (when -f option is set) or return 1 otherwise
#
# Usage: assert_var_not_null [-f] variable ...
#
function assert_var_not_null() {
  local fatal var num_null=0
  [[ "$1" = "-f" ]] && { shift; fatal=1; }
  for var in "$@"; do
    [[ -z "${!var}" ]] &&
      printf '%s\n' "Variable '$var' not set" >&2 &&
      ((num_null++))
  done

  if ((num_null > 0)); then
    [[ "$fatal" ]] && exit 1
    return 1
  fi
  return 0
}

Chamada de amostra:

one=1 two=2
assert_var_not_null one two
echo test 1: return_code=$?
assert_var_not_null one two three
echo test 2: return_code=$?
assert_var_not_null -f one two three
echo test 3: return_code=$? # this code shouldn't execute

Resultado:

test 1: return_code=0
Variable 'three' not set
test 2: return_code=1
Variable 'three' not set

Mais afirmações aqui: https://github.com/codeforester/base/blob/master/lib/assertions.sh

Isso também pode ser uma maneira:

if (set -u; : $HOME) 2> /dev/null
...
...

http://unstableme.blogspot.com/2007/02/checks-whether-envvar-is-set-or-not.html

Nenhuma das soluções acima funcionou para meus propósitos, em parte porque verifiquei o ambiente em busca de uma lista aberta de variáveis ​​que precisam ser definidas antes de iniciar um processo demorado. Eu acabei com isso:

mapfile -t arr < variables.txt

EXITCODE=0

for i in "${arr[@]}"
do
   ISSET=$(env | grep ^${i}= | wc -l)
   if [ "${ISSET}" = "0" ];
   then
      EXITCODE=-1
      echo "ENV variable $i is required."
   fi
done

exit ${EXITCODE}

Em vez de usar scripts de shell externos, costumo carregar funções no meu shell de login. Eu uso algo como isso como uma função auxiliar para verificar as variáveis ​​de ambiente em vez de qualquer variável definida:

is_this_an_env_variable ()
    local var="$1"
    if env |grep -q "^$var"; then
       return 0
    else
       return 1
    fi
 }

A $?sintaxe é bem organizada:

if [ $?BLAH == 1 ]; then 
    echo "Exists"; 
else 
    echo "Does not exist"; 
fi