Wie überprüft man, ob eine Variable in Bash gesetzt ist?

(In der Regel) nicht Der richtige Weg

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

wo ${var+x} ist ein parameter expansion die Auswertung nichts, wenn var nicht gesetzt ist, und ersetzt die Zeichenfolge x sonst.

Zitate Exkurs

Anführungszeichen weggelassen werden können (so können wir sagen ${var+x} statt "${var+x}"), da diese syntax & Nutzung garantiert wird dies nur erweitern auf etwas, das nicht erfordern Anführungszeichen (da es entweder erweitert, um x (enthält kein Wort bricht, so braucht es keine Anführungszeichen) oder nichts (die Ergebnisse in [ -z ]die günstig bewertet, um den gleichen Wert (true), dass [ -z "" ] als auch nicht)).

Jedoch, während Zitate sicher sein kann, weggelassen, und es war nicht sofort offensichtlich ist (es war nicht einmal ersichtlich, um der erste Autor, der diese zitiert Erklärungder auch in einer großen Bash-coder), wäre es manchmal besser sein, schreiben die Lösung mit den Anführungszeichen als [ -z "${var+x}" ] bei den ganz kleinen möglich, Kosten von O(1) speed-Strafe. Der erste Autor hat auch Hinzugefügt, diese als Kommentar neben dem code, die diese Lösung verwenden, die die URL für diese Antwort, die nun auch die Erklärung dafür, warum die Angebote können sicher weggelassen.

(Oft) Der falsche Weg

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

Dies ist oft falsch, weil Sie nicht unterscheiden zwischen einer variable nicht gesetzt ist und eine variable, die auf die leere Zeichenfolge gesetzt. Das heißt, wenn var=''dann die obige Lösung wird mit der Ausgabe "var leer ist".

Die Unterscheidung zwischen "unset" und "auf eine leere Zeichenfolge festgelegt" ist wichtig in Situationen, in denen der Benutzer angeben, eine Erweiterung oder eine zusätzliche Liste von Eigenschaften, und nicht Angabe wird standardmäßig ein nicht-leerer Wert, in der Erwägung, dass die Angabe der leeren Zeichenkette soll das script eine leere Erweiterung oder eine Liste von zusätzlichen Eigenschaften.

Die Unterscheidung kann nicht entscheidend sein, in jedem Szenario obwohl. In diesen Fällen [ -z "$var" ] wird gut.

InformationsquelleAutor der Antwort Lionel

Hier ist, wie um zu testen, ob ein parameter unsetoder leer ("Null") oder set mit einem Wert:

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

Quelle: POSIX: Parameter Expansion:

In allen Fällen gezeigt, mit "Ersatz", der Ausdruck wird ersetzt mit dem Wert angezeigt. In allen Fällen angezeigt, mit "zuweisen", parameter zugeordnet ist, der Wert, der ersetzt auch den Ausdruck.

InformationsquelleAutor der Antwort Jens

Während die meisten der Techniken, die hier angegeben sind, zu korrigieren, bash 4.2 unterstützt einen eigentlichen test für das Vorhandensein einer variable (man bash), anstatt die Prüfung der Wert der Variablen.

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

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

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

InformationsquelleAutor der Antwort Russell Harmon

Finde ich immer die POSIX-Tabelle in der andere Antwort langsam zu verstehen, also hier ist mein nehmen auf Sie:

   +----------------------+------------+-----------------------+-----------------------+
   |   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"  |          ""           |          ""           |
   +----------------------+------------+-----------------------+-----------------------+

Beachten Sie, dass jede Gruppe (mit und ohne vorangehenden Doppelpunkt) hat die gleiche set und unset Fällen, so die einzige Sache, die unterscheidet, ist, wie die leer Fälle behandelt werden.

Mit der vorausgehenden Doppelpunkt, der leer und unset Fällen identisch sind, so würde ich die nutzen, wo möglich (D. H. mit :=nicht nur =weil der leere Koffer ist inkonsistent).

Überschriften:

• set bedeutet VARIABLE ist nicht-leer (VARIABLE="something")
• leer bedeutet VARIABLE ist leer/null (VARIABLE="")
• unset bedeutet VARIABLE existiert nicht (unset VARIABLE)

Werte:

• $VARIABLE bedeutet, das Ergebnis ist der ursprüngliche Wert der Variablen.
• "default" bedeutet das Ergebnis war die Ersatz-Zeichenfolge bereitgestellt.
• "" bedeutet, das Ergebnis ist null (eine leere Zeichenfolge).
• exit 127 bedeutet, dass die script-Ausführung beendet mit exit-code 127.
• $(VARIABLE="default") bedeutet, das Ergebnis ist der ursprüngliche Wert der Variablen und die Ersatz-Zeichenfolge bereitgestellt wird der Variablen zugewiesen, die für die zukünftige Verwendung.

InformationsquelleAutor der Antwort deizel

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

Obwohl für Argumente, die es ist normalerweise am besten, um zu testen,$#, das ist die Anzahl der Argumente, meiner Meinung nach.

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

InformationsquelleAutor der Antwort Paul Creasey

Sie verlassen wollen, wenn es unset

Dieser arbeitete für mich. Ich wollte mein Skript zu beenden mit einer Fehlermeldung, wenn ein parameter nicht gesetzt.

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

Dieser gibt einen Fehler zurück, wenn es ausgeführt

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

Nur prüfen, keine exit - Empty und Unset UNGÜLTIG sind

Versuchen Sie diese option, wenn Sie nur wollen, um zu überprüfen, ob der eingestellte Wert=GÜLTIGE oder nicht gesetzt/leer=UNGÜLTIG.

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

Oder Sogar kurze tests 😉

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

Nur prüfen, keine exit - Nur leere ist UNGÜLTIG

- Und dies ist die Antwort auf die Frage.
Verwenden Sie dies, wenn Sie nur wollen, um zu überprüfen, ob der eingestellte Wert/leer=GÜLTIG oder unset=UNGÜLTIG.

BEACHTEN Sie, dass die "1" in "..-1}" ist unbedeutend,
es kann alles sein (wie 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

Kurze tests

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

Widme ich diese Antwort an @mklement0 (Kommentare), die mich herausgefordert die Frage zu beantworten, genau.

Referenz http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_02

InformationsquelleAutor der Antwort Jarrod Chesney

In der bash können Sie -v innerhalb der [[ ]] builtin:

#! /bin/bash -u

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

echo $SOMEVAR

InformationsquelleAutor der Antwort AlejandroVD

Können Sie tun:

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

InformationsquelleAutor der Antwort codaddict

Mit [[ -z "$var" ]] ist der einfachste Weg, zu wissen, ob eine variable gesetzt wurde oder nicht, aber diese option -z unterscheidet nicht zwischen einem unset variable und eine variable auf einen leeren string gesetzt:

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

Es ist am besten, um zu überprüfen, Sie nach der Art der variable: env-Variablen, - parameter oder normale Variablen.

Für eine env-variable:

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

Für einen parameter (zum Beispiel, um zu überprüfen, die Existenz der parameter $5):

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

Für eine regelmäßige variable (die Verwendung einer aux-Funktion, um es in einer eleganten Art und Weise):

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

Hinweise:

• $#: sagt Ihnen die Anzahl der Parameter.
• declare -p: gibt Ihnen die definition der Variablen als parameter übergeben. Wenn es vorhanden ist, wird 0 zurückgegeben, wenn nicht, gibt 1, und druckt eine Fehlermeldung.
• $?: gibt Ihnen den status-code des letzten ausgeführten Befehls.

InformationsquelleAutor der Antwort Peregring-lk

Meine bevorzugte Art ist diese:

$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

Also im Grunde, wenn eine variable gesetzt ist, wird es "eine negation der daraus resultierenden false" (was true = "set").

Und, wenn es nicht gesetzt ist, wird es "eine negation der daraus resultierenden true" (als leeres Ergebnis ergibt true) (so wird am Ende als false = "NICHT gesetzt").

InformationsquelleAutor der Antwort Aquarius Power

Fand ich einen (viel) besseren code zu tun, wenn Sie prüfen möchten, für alles, was in $@.

if [[ $1 = "" ]] 
dann 
echo "$1 ist leer" 
sonst 
echo '$1 gefüllt' 
fi 

Warum das alles? Alles in $@ besteht in der Bash, aber standardmäßig ist es leer, so test -z und test -n konnte Sie nicht helfen.

Update: Sie können auch zählen die Anzahl der Zeichen in einem Parameter.

if [ ${#1} = 0 ] 
dann 
echo "$1 ist leer" 
sonst 
echo '$1 gefüllt' 
fi 

InformationsquelleAutor der Antwort Zlatan

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

InformationsquelleAutor der Antwort Graham

Dies ist, was ich jeden Tag benutzen:

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

Funktioniert dies auch unter Linux und Solaris down-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

InformationsquelleAutor der Antwort fr00tyl00p

Wenn Sie möchten, um zu testen, ob eine variable gebunden oder ungebunden, das funktioniert gut, sogar nachdem Sie eingeschaltet haben, die die nounset option:

set -o noun set

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

InformationsquelleAutor der Antwort user1857592

Funktionen zu überprüfen, wenn die variable deklariert ist,/unset

einschließlich der leeren $array=()

Die folgenden Funktionen testen, ob der angegebene name existiert als variable

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

• Indem Sie zunächst testen, ob die variable ist (un)eingestellt, wird der Anruf zu erklären, kann vermieden werden, wenn nicht notwendig.
• Wenn jedoch $1 enthält den Namen einer leeren $array=()den Anruf zu erklären, würde sicherstellen, dass wir das richtige Ergebnis
• Es ist nie zu viel Daten an /dev/null as declare wird nur aufgerufen, wenn entweder die variable nicht gesetzt ist oder ein leeres array.

Diese Funktionen testen möchten, wie gezeigt in den folgenden Bedingungen:

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

.

Für mehr details

und ein test-Skript zu sehen meine Antwort auf die Frage "Wie kann ich überprüfen, ob eine variable vorhanden ist, in der bash?".

Bemerkung: Die ähnliche Verwendung von declare -pwie es ist, zeigt auch Peregring-lk's Antwortist wirklich zufällig. Sonst würde ich natürlich gutgeschrieben!

InformationsquelleAutor der Antwort Martin Rüegg