Jaki jest zwięzły sposób sprawdzenia, czy zmienne środowiskowe są ustawione w skrypcie powłoki Uniksa?

Mam kilka skryptów powłoki Unixa, w których muszę sprawdzić, czy pewne zmienne środowiskowe są ustawione, zanim zacznę coś robić, więc robię coś takiego:

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

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

co jest dużo pisania. Czy istnieje bardziej elegancki idiom sprawdzający, czy zestaw zmiennych środowiskowych jest ustawiony?

EDYCJA: Powinienem wspomnieć, że te zmienne nie mają żadnej znaczącej wartości domyślnej - skrypt powinien błędnie skasować, jeśli są ustawione

Rozszerzenie parametru

Oczywistą odpowiedzią jest użycie jednej ze specjalnych form rozszerzania parametrów:

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

Lub lepiej (patrz sekcja „Pozycja podwójnych cudzysłowów” poniżej):

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

Pierwszy wariant (używając just ?) wymaga ustawienia STATE, ale STATE = "" (pusty ciąg znaków) jest OK - nie dokładnie to, czego chcesz, ale alternatywna i starsza notacja.

Drugi wariant (użycie :?) wymaga ustawienia DEST i niepustego.

Jeśli nie podasz żadnego komunikatu, powłoka wyświetli komunikat domyślny.

${var?}Konstrukt jest przenośny powrotem do Version 7 UNIX i Bourne Shell (1978) lub w jej pobliżu. ${var:?}Konstrukt jest nieco nowsza: Myślę, że to było w systemie III UNIX około 1981, ale może to być w PWB UNIX wcześniej. Znajduje się zatem w powłoce Korna i powłokach POSIX, w tym szczególnie w Bash.

Zwykle jest to udokumentowane na stronie podręcznika powłoki w sekcji o nazwie Rozszerzenie parametru . Na przykład bashinstrukcja mówi:

${parameter:?word}

Błąd wyświetlania, jeśli Null lub Unset. Jeśli parametr ma wartość NULL lub jest nieustawiony, rozwinięcie słowa (lub komunikat o tym, jeśli słowo nie jest obecne) jest zapisywany do standardowego błędu i powłoka, jeśli nie jest interaktywna, kończy działanie. W przeciwnym razie wartość parametru zostanie podstawiona.

Komenda dwukropka

Powinienem chyba dodać, że polecenie dwukropka po prostu ocenia swoje argumenty, a następnie się udaje. Jest to oryginalna notacja komentarza powłoki (przed „ #” do końca wiersza). Przez długi czas pierwsze skrypty skryptów Bourne'a miały dwukropek. Powłoka C czytałaby skrypt i używałaby pierwszego znaku, aby ustalić, czy chodzi o Powłokę C ( #skrót), czy powłokę Bourne'a ( :dwukropek). Następnie jądro wzięło udział w akcji i dodało wsparcie dla komentarzy, a #!/path/to/programpowłoka Bourne'a dostała #komentarze, a konwencja okrężnicy poszła na marne. Ale jeśli natrafisz na skrypt rozpoczynający się dwukropkiem, teraz będziesz wiedział, dlaczego.

Pozycja podwójnych cytatów

blong zapytał w komentarzu :

Jakieś przemyślenia na temat tej dyskusji? https://github.com/koalaman/shellcheck/issues/380#issuecomment-145872749

Istotą dyskusji jest:

… Jednak kiedy shellcheckto zrobię (w wersji 0.4.1), otrzymuję ten komunikat:

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.

Wszelkie porady dotyczące tego, co powinienem zrobić w tym przypadku?

Krótka odpowiedź brzmi „rób jak shellchecksugeruje”:

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

Aby zilustrować przyczynę, przestudiuj poniższe. Zauważ, że :polecenie nie powtarza swoich argumentów (ale powłoka ocenia argumenty). Chcemy zobaczyć argumenty, więc poniższy kod używa printf "%s\n"zamiast :.

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

Zwróć uwagę, w jaki sposób wartość in $xjest rozwijana do najpierw, *a następnie listy nazw plików, gdy ogólne wyrażenie nie jest w cudzysłowach. To, co shellcheckzaleca, powinno zostać naprawione. Nie sprawdziłem, czy nie sprzeciwia się formie, w której wyrażenie jest ujęte w podwójne cudzysłowy, ale uzasadnione jest założenie, że byłoby OK.

Spróbuj tego:

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

Twoje pytanie zależy od używanej powłoki.

Skorupa Bourne'a pozostawia bardzo mało na drodze do tego, czego szukasz.

ALE...

Działa, prawie wszędzie.

Po prostu staraj się trzymać z dala od csh. To było dobre dla dzwonków i gwizdów, które dodał, w porównaniu do skorupy Bourne'a, ale teraz naprawdę trzeszczy. Jeśli mi nie wierzysz, po prostu spróbuj rozdzielić STDERR w csh! (-:

Istnieją tutaj dwie możliwości. Powyższy przykład, a mianowicie użycie:

${MyVariable:=SomeDefault}

po raz pierwszy musisz zapoznać się z $ MyVariable. To zajmuje środowisko. var MyVariable i, jeśli nie jest aktualnie ustawiony, przypisuje wartość SomeDefault do zmiennej do późniejszego wykorzystania.

Masz również możliwość:

${MyVariable:-SomeDefault}

który po prostu zastępuje SomeDefault zmienną, w której używasz tej konstrukcji. Nie przypisuje wartości SomeDefault do zmiennej, a wartość MyVariable nadal będzie pusta po napotkaniu tej instrukcji.

Z pewnością najprostszym podejściem jest dodanie -uprzełącznika do shebang (linii u góry skryptu), zakładając, że używasz bash:

#!/bin/sh -u

Spowoduje to zamknięcie skryptu, jeśli czają się w nim niezwiązane zmienne.

${MyVariable:=SomeDefault}

Jeśli MyVariablejest ustawiony, a nie null, zresetuje wartość zmiennej (= nic się nie dzieje).
W przeciwnym razie MyVariableustawiona jest wartość SomeDefault.

Powyższe spróbuje wykonać ${MyVariable}, więc jeśli chcesz ustawić zmienną, wykonaj:

MyVariable=${MyVariable:=SomeDefault}

Moim zdaniem najprostszym i najbardziej zgodnym sprawdzaniem #! / Bin / sh jest:

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

Ponownie, dotyczy to / bin / sh i jest kompatybilny również ze starymi systemami Solaris.

bash4.2 wprowadził -voperator, który sprawdza, czy nazwa ma jakąkolwiek wartość, nawet pusty ciąg znaków.

$ 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

Zawsze używałem:

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

Obawiam się, że nie jest to bardziej zwięzłe.

W ramach CSH masz $? STATE.

Dla przyszłych ludzi takich jak ja chciałem zrobić krok do przodu i sparametryzować nazwę zmiennej, aby móc przeglądać listę nazw zmiennych o zmiennej wielkości:

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

Możemy napisać niezłe twierdzenie, aby sprawdzić kilka zmiennych jednocześnie:

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

Przykładowe wywołanie:

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

Wynik:

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

Więcej takich twierdzeń tutaj: https://github.com/codeforester/base/blob/master/lib/assertions.sh

To też może być sposób:

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

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

Żadne z powyższych rozwiązań nie zadziałało dla moich celów, częściowo dlatego, że sprawdzam środowisko pod kątem otwartej listy zmiennych, które należy ustawić przed rozpoczęciem długiego procesu. Skończyło się na tym:

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}

Zamiast używać zewnętrznych skryptów powłoki, zwykle ładuję funkcje w mojej powłoce logowania. Używam czegoś takiego jako funkcji pomocniczej do sprawdzania zmiennych środowiskowych zamiast jakiejkolwiek zmiennej ustawionej:

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

$?Składnia jest bardzo czysty:

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