Wie prüfe ich, ob eine Variable in der Bash gesetzt ist?

Wie finde ich heraus, ob eine Variable in der Bash gesetzt ist?

Zum Beispiel, wie man prüft, ob der Benutzer den ersten Parameter der Funktion angegeben hat?

 function a { # if $1 is set ? } 
1189
30 авг. set prosseek 30 aug. 2010-08-30 17:54 '10 um 17:54 30.08.2010 17:54
ответ 31 Antworten
  • 1
  • 2

(Normalerweise) der richtige Weg

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

Dabei ist ${var+x} die Parametererweiterung, die nichts berechnet, wenn var nicht angegeben ist, und ansonsten die Zeichenfolge x ersetzt.

Zitatabweichung

Anführungszeichen können weggelassen werden (wir können also ${var+x} anstelle von "${var+x}" sagen), da diese Syntax und Verwendung sicherstellt, dass sie nur in dem Maße erweitert wird, in dem sie keine Anführungszeichen benötigt (weil sie es auch nicht) erweitert sich zu x (das keine Wortumbrüche enthält, sodass keine Anführungszeichen erforderlich sind) oder nichts (was zu [ -z ] , was bequem mit dem gleichen Wert (true) wie [ -z "" ] auszuwerten ist).

Zitate können zwar sicher weggelassen werden, und es war nicht für jedermann sofort offensichtlich (für den Erstautor dieser Erklärung waren Zitate nicht einmal offensichtlich, was auch der Hauptcode von Bash ist), aber manchmal wäre es besser, eine Lösung mit Zitate wie [ -z "${var+x}" ] zu sehr geringen möglichen Feinkosten für den O (1) -Satz. Der Erstautor fügte dies als Kommentar neben dem Code hinzu, der diese Lösung verwendet, und gibt die URL dieser Antwort an, die nun auch eine Erklärung enthält, warum Zitate sicher weggelassen werden können.

(Oft) falsch

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

Dies ist oft falsch, da es nicht zwischen einer ungültigen und einer leeren Zeichenfolge unterscheidet. Das heißt, wenn var='' , erzeugt die obige Lösung "var ist leer".

Die Unterscheidung zwischen unset und dem leeren String ist in Situationen wichtig, in denen der Benutzer eine Erweiterung oder eine zusätzliche Eigenschaftsliste angeben und nicht standardmäßig einen nicht leeren Wert angeben muss, während die Angabe eines leeren Strings das Skript zu einem leeren Zusatz oder einer Liste zusätzlicher Eigenschaften machen soll.

Der Unterschied ist jedoch möglicherweise nicht in jedem Szenario erforderlich. In solchen Fällen ist [ -z "$var" ] in Ordnung.

1799
13 дек. Die Antwort wird von Lionel am 13. Dezember gegeben. 2012-12-13 20:04 '12 um 20:04 Uhr 2012-12-13 20:04

Um zu überprüfen, ob die Stringvariable nicht -n ULL / nicht -z ist, d. H. Wenn installiert, verwenden Sie

 if [ -n "$1" ] 

Dies ist das Gegenteil von -z . Ich benutze -n mehr als -z .

border=0

Sie würden es gerne verwenden:

 if [ -n "$1" ]; then echo "You supplied the first parameter!" else echo "First parameter not supplied." fi 
709
30 авг. die antwort wird mbrannig august 30 gegeben. 2010-08-30 18:17 '10 am 6:17 PM 2010-08-30 18:17

Hier können Sie überprüfen, ob der nicht gesetzte Parameter festgelegt ist, entweder leer ("Null") oder mit dem 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: Parametererweiterung :

In allen Fällen, die mit dem "Ersatz" angezeigt werden, wird der Ausdruck durch den angezeigten Wert ersetzt. In allen Fällen, die durch Zuweisen angezeigt werden, wird dieser Zuweisung ein Wert zugewiesen, der auch den Ausdruck ersetzt.

408
25 мая '13 в 23:20 2013-05-25 23:20 Die Antwort wird von Jens 25. Mai 13 um 23:20 2013-05-25 23:20 gegeben

Obwohl die meisten der hier beschriebenen Methoden korrekt sind, unterstützt bash 4.2 den tatsächlichen Test auf das Vorhandensein einer Variablen ( man bash ) und testet den Wert der Variablen nicht.

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

Es ist bemerkenswert, dass dieser Ansatz keine Fehler verursacht, wenn er verwendet wird, um die set -u Variable im set -u / set -o nounset , im Gegensatz zu vielen anderen Ansätzen, wie z. B. [ -z .

173
09 июля '13 в 5:28 2013-07-09 05:28 Die Antwort wird von Russell Harmon am 9. Juli 13 um 5:28 2013-07-09 05:28 gegeben

Es gibt viele Möglichkeiten, dies zu tun, eine davon ist die folgende:

 if [ -z "$1" ] 

Dies wird ausgeführt, wenn $ 1 null oder unset ist

169
30 авг. Antwort von ennuikiller 30. Aug. 2010-08-30 18:00 '10 um 18:00 Uhr 2010-08-30 18:00 Uhr

Um herauszufinden, ob eine Variable variabel ist, verwende ich

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

Gegentests, wenn die Variable nicht gesetzt oder leer ist:

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

Um herauszufinden, ob eine Variable gesetzt ist (leer oder nicht leer), verwende ich

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

Gegentests, wenn die Variable nicht gesetzt ist:

 if [[ ! ${var+x} ]]; then ... # `var' is not set at all if [[ ! ${1+x} ]]; then ... # We were called with no arguments 
57
08 мая '13 в 11:32 2013-05-08 11:32 Die Antwort wird von phkoester am 8. Mai 13 um 11:32 2013-05-08 11:32 gegeben

Ich finde die POSIX-Tabelle immer in einer anderen Antwort >

  +----------------------+------------+-----------------------+-----------------------+ | 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 vorangestellten Doppelpunkt) dieselbe Menge hat und Fälle abbricht. Die einzige Sache, die sich unterscheidet, ist die Behandlung von leeren Fällen.

Im vorherigen Doppelpunkt sind die leeren und nicht spezifizierten Fälle identisch, daher würde ich sie verwenden, wo dies möglich war (dh verwenden Sie := und nicht nur = , da der leere Fall nicht kompatibel ist).

Schlagzeilen:

  • set VARIABLE nicht leer ( VARIABLE="something" )
  • empty bedeutet VARIABLE empty / null ( VARIABLE="" )
  • unset bedeutet, dass VARIABLE nicht existiert ( unset VARIABLE )

Werte:

  • $VARIABLE bedeutet, dass das Ergebnis der ursprüngliche Wert der Variablen ist.
  • "default" bedeutet, dass das Ergebnis eine Ersatzzeichenfolge war.
  • "" bedeutet, dass das Ergebnis null ist (leere Zeichenfolge).
  • exit 127 bedeutet, dass das Skript mit Exitcode 127 beendet wird.
  • $(VARIABLE="default") bedeutet, dass das Ergebnis der ursprüngliche Wert der Variablen ist und der bereitgestellte Ersetzungsstring der Variablen zur späteren Verwendung zugewiesen wird.
46
17 июня '17 в 18:19 2017-06-17 18:19 Die Antwort wird gegeben deizel 17. Juni 17 um 18:19 2017-06-17 18:19

In der modernen Version von Bash (Version 4.2 oder höher, glaube ich nicht sicher) weiß ich Folgendes:

 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 
31
26 авг. Antwort von Seamus Connor 26 Aug. 2013-08-26 19:24 13 um 19:24 2013-08-26 19:24
 if [ "$1" != "" ]; then echo \$1 is set else echo \$1 is not set fi 

Obwohl für Argumente in der Regel in der Regel das Kontrollkästchen $ #, also die Anzahl der Argumente, angezeigt wird.

 if [ $# -gt 0 ]; then echo \$1 is set else echo \$1 is not set fi 
18
30 авг. Antwort von Paul Creasey 30 Aug. 2010-08-30 18:00 '10 um 18:00 Uhr 2010-08-30 18:00 Uhr

Möchten Sie das Programm beenden, wenn es deaktiviert ist?

Es hat für mich funktioniert. Ich wollte, dass mein Skript eine Fehlermeldung ausgibt, wenn der Parameter nicht festgelegt wurde.

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

Dies wird beim Start mit einem Fehler zurückgegeben.

 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, kein Beenden - Leer und Nicht gesetzt - UNGÜLTIG

Verwenden Sie diese Option, wenn Sie nur prüfen möchten, ob value = VALID gesetzt ist oder unset / empty = 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 

Oder sogar kurze Tests; -)

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

Nur prüfen, kein Exit - nur leer - INVALID

Und das ist die Antwort auf die Frage. Verwenden Sie dies, wenn Sie nur prüfen möchten, ob der Wert auf / empty = VALID oder unset = INVALID gesetzt ist.

HINWEIS. "1" in "..- 1" "etwas, es könnte alles sein (z. B. 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" 

Ich widme diese Antwort @ mklement0 (Kommentaren), die mich dazu aufgefordert haben, die Frage genau zu beantworten.

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

15
09 дек. Antwort von Jarrod Chesney Dez 09 2016-12-09 06:34 '16 um 06:34 Uhr 2016-12-09 06:34

Lesen Sie den Abschnitt "Expanding Parameters" auf der bash Handbuchseite. Die Erweiterung von Parametern ist kein allgemeiner Test für eine gegebene Variable. Es gibt jedoch einige Möglichkeiten, mit einem Parameter zu arbeiten, wenn er nicht festgelegt ist.

Zum Beispiel:

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

setzt first_arg auf $1 wenn es zugewiesen ist, andernfalls wird der Wert "foo" verwendet. Wenn a unbedingt erforderlich ist, um einen Parameter zu übernehmen, und es keinen guten Standardwert gibt, können Sie mit einer Fehlermeldung abbrechen, wenn der Parameter nicht angegeben ist:

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

(Beachten Sie den Befehl use : als Nullbefehl, der die Werte seiner Argumente einfach erweitert. In diesem Beispiel möchten wir nichts mit $1 tun, sondern nur beenden, wenn er nicht gesetzt ist.)

14
01 февр. Die Antwort ist gegeben chepner 01 Feb. 2012-02-01 01:05 '12 um 1:05 2012-02-01 01:05

Um zu überprüfen, ob eine Variable mit einem nicht leeren Wert festgelegt ist, verwenden Sie [ -n "$x" ] , wie von anderen angegeben.

In den meisten Fällen wird empfohlen, eine Variable mit einem leeren Wert wie eine nicht festgelegte Variable zu verarbeiten. Sie können jedoch zwischen zwei unterscheiden, wenn Sie [ -n "${x+set}" ] benötigen: [ -n "${x+set}" ] ( "${x+set}" erweitert, wenn x , und eine leere Zeichenfolge, wenn x nicht gesetzt ist).

Um zu prüfen, ob der Parameter übergeben wurde, testen Sie $# . Dies ist die Anzahl der Parameter, die an die Funktion (oder im Skript, falls nicht in der Funktion) übergeben werden (siehe Antwort von Paul ).

12
31 авг. Die Antwort wird von Gilles 31 Aug gegeben. 2010-08-31 10:30 '10 um 10:30 Uhr 2010-08-31 10:30 Uhr

In Bash können Sie -v innerhalb der integrierten [[ ]] :

 #! /bin/bash -u if [[ ! -v SOMEVAR ]]; then SOMEVAR='hello' fi echo $SOMEVAR 
12
08 февр. Die Antwort ist gegeben AlejandroVD 08 Feb. 2016-02-08 16:31 '16 am 16:31 2016-02-08 16:31

Für diejenigen, die prüfen wollen, wird nicht zurückgesetzt oder nicht, wenn im Skript mit set -u :

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

Normal [ -z "$var" ] wird nicht mit var; unbound variable var; unbound variable var; unbound variable var; unbound variable wenn set -u aber [ -z "${var-}" ] zu einer leeren Zeichenfolge erweitert wird , wenn var nicht [ -z "${var-}" ] installiert wird.

11
16 нояб. Die Antwort wird am 16. November von ecerulm gegeben . 2016-11-16 14:26 '16 um 14:26 Uhr 2016-11-16 14:26

Die obigen Antworten funktionieren nicht, wenn die Option Bash- set -u aktiviert ist. Außerdem sind sie nicht dynamisch. Wie wird zum Beispiel eine Variable mit dem Namen "dummy" geprüft? Versuchen Sie folgendes:

 is_var_defined() { if [ $# -ne 1 ] then echo "Expected exactly one argument: variable name as string, eg, '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. } 

Verwandte Themen: Wie kann ich in Bash überprüfen, ob eine Variable im Modus "-u" definiert ist

4
09 нояб. Die Antwort wird von kevinarpe 09 Nov. gegeben. 2013-11-09 11:55 13 um 11:55 2013-11-09 11:55

Sie können tun:

 function a { if [ ! -z "$1" ]; then echo '$1 is set' fi } 
4
30 авг. Antwort von codaddict 30. August 2010-08-30 18:01 '10 um 18:01 2010-08-30 18:01

Wenn var ein Array sein kann, ist die Ersetzung des Parameters [ -z "${var+x}" ] falsch. Um sicher zu sein, dass Bash verwendet wird, müssen Sie eine Array-Syntax verwenden, beispielsweise [ "${#var[@]}" = 0 ] (siehe unten).

 is-var-set () { results="\${var+x}=${var+x}\t\${#var[@]}=${#var[@]}" if [ -z "${var+x}" ]  [ "${#var[@]}" = 0 ]; then echo -e "$1: var 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 } 

In fast allen Fällen stimmen sie zu. Die einzige Situation, in der ich die Array-Methode gefunden habe, ist genauer, wenn die Variable ein nicht leeres Array mit einer Nullposition von 0 (beispielsweise in den Tests 7 und A unten). Diese Diskrepanz tritt auf, weil $var eine Abkürzung für ${var[0]} ist. [ -z "${var+x}" ] überprüft [ -z "${var+x}" ] nicht das gesamte Array.

Hier sind meine Tests:

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

Hier ist die Schlussfolgerung:

2
15 февр. Antwort von Mark Haferkamp am 15. Februar 2016-02-15 17:32 '16 um 17:32 Uhr 2016-02-15 17:32

Die Verwendung von [[ -z "$var" ]] ist der einfachste Weg, um herauszufinden, ob eine Variable festgelegt wurde oder nicht. Die Option -z unterscheidet jedoch nicht zwischen einer -z Variablen und einer Variablen, die auf einen leeren String gesetzt ist:

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

Es ist am besten, sie entsprechend dem Typ der Variablen zu prüfen: Umgebungsvariable, Parameter oder reguläre Variable.

Für die env-Variable:

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

Für einen Parameter (zum Beispiel, um das Vorhandensein eines Parameters $5 zu prüfen):

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

Für eine reguläre Variable (mit Hilfe einer Hilfsfunktion, um dies auf elegante Weise durchzuführen):

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

Anmerkungen:

  • $# : gibt die Anzahl der Positionsparameter an.
  • declare -p : gibt die Definition einer als Parameter übergebenen Variablen an. Falls vorhanden, wird 0 zurückgegeben, andernfalls 1, und eine Fehlermeldung wird angezeigt.
  • $? : gibt den Statuscode des zuletzt ausgeführten Befehls an.
2
19 окт. die antwort ist gegeben Peregring-lk 19 oct. 2014-10-19 01:09 '14 um 1:09 2014-10-19 01:09

Meine bevorzugte Methode:

 $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 

Wenn eine Variable gesetzt ist, wird sie prinzipiell zu einer "Negation des resultierenden false " (die auf " true " gesetzt wird).

Wenn es nicht gesetzt ist, wird es "die Negation des resultierenden true " (da das leere Ergebnis als true ausgewertet wird) (es endet also als false = "NOT Set").

1
15 нояб. Die Antwort wird Aquarius Power 15 November gegeben. 2014-11-15 20:55 14 um 20:55 2014-11-15 20:55

In der Shell können Sie den Operator -z , der True ist, wenn die Länge der Zeichenfolge Null ist.

Ein einfaches einzeiliges Set für die Standardinstallation MY_VAR , falls es nicht installiert ist. Andernfalls können Sie die Meldung anzeigen:

 [[ -z "$MY_VAR" ]]  MY_VAR="default" [[ -z "$MY_VAR" ]]  MY_VAR="default" || echo "Variable already set." 
1
22 сент. Antwort an Kenorb vom 22. September 2014-09-22 16:57 '14 um 16:57 2014-09-22 16:57
 if [[ ${!xx[@]} ]] ; then echo xx is defined; fi 
0
11 февр. Die Antwort wird am 11. Februar von Graham gegeben . 2015-02-11 23:51 '15 am 23:51 2015-02-11 23:51
 if [[ ${1:+isset} ]] then echo "It was set and not null." > else echo "It was not set or it was null." > fi if [[ ${1+isset} ]] then echo "It was set but might be null." > else echo "It was was not set." > fi 
0
30 июня '13 в 8:22 2013-06-30 08:22 Die Antwort wird am 30. Juni 13 um 8:22 30. Juni 13 um 08:22 Uhr gegeben

Ich habe (viel) besseren Code dafür gefunden, wenn Sie etwas in $@ prüfen wollen.

 if [[$ 1 = ""]] dann   Echo '$ 1 ist leer' sonst   Echo '$ 1 ist aufgefüllt' fi

Warum das alles? Alles in $@ ist in Bash vorhanden, aber standardmäßig ist es leer. test -z und test -n können Ihnen also nicht helfen.

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

 wenn [$ {# 1} = 0] dann   Echo '$ 1 ist leer' sonst   Echo '$ 1 ist aufgefüllt' fi
0
18 нояб. Die Antwort wird Zlatan 18 November gegeben. 2013-11-18 17:44 13 um 17:44 2013-11-18 17:44

Ich verwende diese Methode immer, basierend auf der Tatsache, dass es einfach ist, jemanden zu verstehen, der den Code zum ersten Mal sieht:

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

Und wenn Sie überprüfen möchten, ob es leer ist,

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

Was ist das.

0
07 сент. antworten gegeben mijnnaam 07 sep . 2013-09-07 12:06 13 am 12:06 2013-09-07 12:06

Das nutze ich jeden Tag:

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

Es funktioniert gut unter Linux und Solaris vor 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 
0
11 дек. Die Antwort wird von fr00tyl00p am 11. Dezember gegeben. 2014-12-11 18:24 '14 um 18:24 2014-12-11 18:24
 (( ${#foo} )) 

oder

 declare -p foo 
0
11 мая '14 в 7:59 2014-05-11 07:59 Die Antwort wird von Steven Penny am 11. Mai 14 um 07:59 2014-05-11 07:59 gegeben

Ich mag die Helferfunktionen, um die groben Details von bash zu verbergen. In diesem Fall fügt es noch mehr (verdeckte) Unhöflichkeit hinzu:

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

Da ich zum ersten Mal Fehler bei dieser Implementierung hatte (inspiriert durch die Antworten von Jens und Lionel), habe ich eine andere Lösung gefunden:

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

Ich finde es einfacher, baskischer und einfacher zu verstehen / zu erinnern. Im Testfall entspricht dies:

 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 

Der Testfall zeigt auch, dass local var NICHT local var deklariert (es sei denn, Sie folgen '='). Ich habe einige Zeit gedacht, dass ich die Variablen auf diese Weise deklariert habe, nur um jetzt herauszufinden, dass ich gerade meine Absicht geäußert habe ... Das ist nicht-op, denke ich.

IsDeclared_Tricky xyz: 1
IsDeclared_Tricky foo: 1
IsDeclared_Tricky-Panel: 0
IsDeclared_Tricky baz: 0
IsDeclared xyz: 1
IsDeclared foo: 1
IsDeclared-Bereich: 0
IsDeclared Baz: 0

BONUS: Verwendungszweck

Ich verwende diesen Test hauptsächlich, um Funktionen auf eine etwas "elegante" und sichere Weise zu geben (und zurückzugeben) (die fast einer Schnittstelle ähnelt ...):

 #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 

Wenn für einen Aufruf mit allen deklarierte Variablen erforderlich sind:

Hallo Welt!

noch:

Fehler: Variable nicht deklariert: outputStr

-1
01 марта '16 в 16:12 2016-03-01 16:12 Die Antwort wird von Daniel S am 01. März '16 um 16:12 2016-03-01 16:12 gegeben

Wenn Sie prüfen möchten, ob die Variable gebunden oder ungebunden ist, funktioniert dies auch nach dem Aktivieren der Nomenset-Option:

 set -o noun set if printenv variableName >/dev/null; then # variable is bound to a value else # variable is unbound fi 
-1
25 мая '13 в 23:01 2013-05-25 23:01 Die Antwort wird von user1857592 am 25. Mai 13 um 23:01 Uhr gegeben. 2013-05-25 23:01

Funktionen zur Überprüfung, ob eine Variable gesetzt ist / nicht gesetzt ist

einschließlich leerer $array=()


Die folgenden Funktionen prüfen, ob der angegebene Name als Variable existiert.

 # 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  } var_is_unset() { { [[ -z ${!1+anything} ]]  ! declare -p $1  } 
  • При первом тестировании, если переменная (un) установлена, вызов declare можно избежать, если это не необходимо.
  • Если, однако, $1 содержит имя пустого $array=() , вызов объявления будет гарантировать, что мы получим правильный результат
  • До сих пор не передавалось много данных в /dev/null, поскольку declare вызывается только в том случае, если переменная не установлена ​​или пустой массив.