Kaip patikrinti, ar kintamasis nustatytas bash?

Kaip sužinoti, ar kintamasis nustatytas bash?

Pavyzdžiui, kaip patikrinti, ar vartotojas davė pirmąjį funkcijos parametrą?

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

(Paprastai) Teisingas kelias

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

kur ${var+x} yra parametro plėtinys, kuris nieko nekainuoja, jei var nenurodytas ir pakeičia eilutę x kitaip.

Citavimo nuokrypis

Citatos gali būti praleidžiamos (todėl mes galime pasakyti ${var+x} vietoj "${var+x}" ), nes ši sintaksė ir naudojimas užtikrina, kad ji išsiplės tik tiek, kiek nereikalauja kabučių plečiasi į x (kuris neturi žodžių pertraukų, todėl nereikalauja kabučių) arba nieko (kuris veda prie [ -z ] , kuris yra patogu įvertinti tą pačią vertę (tiesa) kaip [ -z "" ] ).

Tačiau, nors citatos gali būti saugiai praleidžiamos, ir tai nebuvo akivaizdi visiems ( pirmasis šio paaiškinimo autorius, kabutės nebuvo net akivaizdžios, o tai taip pat yra pagrindinis „Bash“ koderis), kartais būtų geriau parašyti sprendimą su citatomis, pvz. [ -z "${var+x}" ] labai mažomis [ -z "${var+x}" ] O (1) tarifo kainomis. Pirmasis autorius taip pat pridėjo šį komentarą šalia kodo, naudodamas šį sprendimą, nurodydamas šio atsakymo URL, kuris taip pat apima paaiškinimą, kodėl citatos gali būti saugiai praleidžiamos.

(Dažnai) Klaidingas

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

Dažnai tai neteisinga, nes ji nesiskiria negaliojančiu kintamuoju ir kintamuoju, kuris nustatytas į tuščią eilutę. Tai reiškia, kad jei var='' , tada aukščiau pateiktas sprendimas sukurs "var yra tuščias".

Skirtumas tarp išjungimo ir nustatymo į tuščią eilutę yra svarbus situacijose, kai vartotojas turi nurodyti išplėtimą arba papildomą nuosavybės sąrašą, o ne pagal nutylėjimą nenurodyti tuščios vertės, o tuščios eilutės nustatymas turėtų padaryti scenarijų tuščiu papildymu arba papildomų savybių sąrašu.

Tačiau kiekvienas scenarijus gali būti nereikalingas. Tokiais atvejais [ -z "$var" ] bus gerai.

1799 m
13 дек. Atsakymą pateikė Lionel . 2012-12-13 20:04 '12 8:04 val. 2012-12-13 20:04

Norėdami patikrinti eilutės kintamąjį nėra -n ULL / ne -z, t.y. Jei įdiegta, naudokite

 if [ -n "$1" ] 

Tai yra -z . Aš naudoju -n daugiau nei -z .

border=0

Jūs jį naudėtumėte kaip:

 if [ -n "$1" ]; then echo "You supplied the first parameter!" else echo "First parameter not supplied." fi 
709
30 авг. atsakymas pateikiamas mbrannig 30 rug . 2010-08-30 18:17 '10, 18:17 PM 2010-08-30 18:17

Čia, kaip patikrinti, ar išjungimo parametras nustatytas, arba tuščias („Null“), arba su reikšme :

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

Šaltinis: POSIX: parametrų plėtra :

Visais atvejais, kai rodomas „pakaitalas“, išraiška pakeičiama rodoma verte. Visais atvejais, rodomais naudojant priskyrimą, ši užduotis priskiriama reikšmė, kuri taip pat pakeičia išraišką.

408
25 мая '13 в 23:20 2013-05-25 23:20 Atsakymą pateikė Jensas gegužės 25 d. 13 val. 23:20 2013-05-25 23:20

Nors dauguma čia aprašytų metodų yra teisingi, bash 4.2 palaiko faktinį testą kintamojo buvimui ( žmogus bash ), o ne bando kintamojo vertės.

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

Pažymėtina, kad šis metodas nesukels klaidų, kai bandomas set -u kintamasis set -u / set -o nounset , skirtingai nei daugelis kitų metodų, pavyzdžiui, naudojant [ -z .

173
09 июля '13 в 5:28 2013-07-09 05:28 atsakymą pateikė Russell Harmon, liepos 13 d., 13 val., 5:28, 2013-07-09 05:28

Yra daug būdų tai padaryti, vienas iš šių būdų:

 if [ -z "$1" ] 

Tai įvykdoma, jei $ 1 yra nulinis arba išjungtas

169
30 авг. Ennuikiller atsakymas, rugpjūčio 30 d. 2010-08-30 18:00 '10 18:00 val. 2010-08-30 18:00

Norėdami sužinoti, ar kintamasis yra kintamas, aš naudoju

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

Priešais bandymus, jei kintamasis nėra nustatytas arba tuščias:

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

Norėdami sužinoti, ar kintamasis yra nustatytas (tuščias ar ne tuščias), naudoju

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

Priešais bandymus, jei kintamasis nėra nustatytas:

 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 atsakymą phkoester pateikia gegužės 08 d. 13 val. 11:32 2013-05-08 11:32

POSIX lentelę visada rasiu kitame atsakyme lėtai suprasti, todėl čia aš paimsiu:

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

Atkreipkite dėmesį, kad kiekviena grupė (su ir be ankstesnio dvitaškio) turi tą patį rinkinį ir atšaukia atvejus, taigi vienintelis dalykas, kuris skiriasi, yra tai, kaip tvarkomi tuščios bylos.

Ankstesniame dvitaškyje tuščios ir nenurodytos bylos yra identiškos, todėl norėčiau jas naudoti ten, kur tai buvo įmanoma (ty naudoti := , ir ne tik = , nes tuščias atvejis yra nesuderinamas).

Antraštės:

  • rinkinys VARIABLE nėra tuščias ( VARIABLE="something" )
  • tuščios priemonės VARIABLE / null ( VARIABLE="" )
  • išjungimo priemonė „ VARIABLE “ neegzistuoja ( unset VARIABLE )

Vertės:

  • $VARIABLE reiškia, kad rezultatas yra pradinė kintamojo vertė.
  • "default" reiškia, kad rezultatas buvo pakaitinė eilutė.
  • "" reiškia, kad rezultatas yra nulinis (tuščia eilutė).
  • exit 127 reiškia, kad scenarijus baigiasi su išėjimo kodu 127.
  • $(VARIABLE="default") reiškia, kad rezultatas yra pradinė kintamojo vertė, o numatytas pakeitimo eilutė priskiriama kintamajam būsimam naudojimui.
46
17 июня '17 в 18:19 2017-06-17 18:19 atsakymas duotas deizel birželio 17 d. 17:19 2017-06-17 18:19

Šiuolaikinėje „Bash“ versijoje (4.2 ar naujesnė versija, manau, nežinau, tikrai), norėčiau pabandyti:

 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 авг. atsakymas, kurį pateikė Seamus Connor 26 rug. 2013-08-26 19:24 '13, 19:24, 2013-08-26 19:24
 if [ "$1" != "" ]; then echo \$1 is set else echo \$1 is not set fi 

Nors argumentams, kaip taisyklė, geriausia patikrinti $ #, tai yra mano nuomone, argumentų skaičius.

 if [ $# -gt 0 ]; then echo \$1 is set else echo \$1 is not set fi 
18
30 авг. atsakymą pateikė Paul Creasey 30 rug . 2010-08-30 18:00 '10 18:00 val. 2010-08-30 18:00

Ar norite išeiti, jei jis yra išjungtas

Jis dirbo man. Norėjau, kad mano scenarijus pateiktų klaidos pranešimą, jei parametras nebuvo nustatytas.

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

Tai grąžinama, kai paleidžiama klaida.

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

Patikrinkite tik, neišeiti - tuščias ir išjungtas - neįmanoma

Išbandykite šią parinktį, jei norite tik patikrinti, ar reikšmė = VALID yra nustatyta, ar išjungta / tuščia = 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 

Arba net trumpus testus; -)

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

Patikrinkite tik, nėra išėjimo - tik tuščias - INVALID

Ir tai yra atsakymas į klausimą. Naudokite šią funkciją, jei norite tik patikrinti, ar reikšmė nustatyta į / tuščias = VALIDAS arba išjungtas = INVALID.

PASTABA. "1" į "..- 1" "šiek tiek, tai gali būti bet kas (pvz., 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 

Trumpi bandymai

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

Šį atsakymą skiriu @ mklement0 (komentarai), kuris mane ginčijo tiksliai atsakydamas į šį klausimą.

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

15
09 дек. Atsakymas, kurį pateikė Jarrod Chesney, gruodžio 09 2016-12-09 06:34 '16 at 6:34 am 2016-12-09 06:34

Perskaitykite skyrių „Parametrų išplėtimas“, esantį „ bash puslapyje. Parametrų išplėtimas nesuteikia bendro konkretaus kintamojo testo, tačiau yra keletas dalykų, kuriuos galite atlikti su parametru, jei jis nėra nustatytas.

Pavyzdžiui:

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

jei jis bus priskirtas, jis nustatys first_arg į $1 , kitaip jis naudoja vertę "foo". Jei a būtinas norint paimti vieną parametrą ir nėra geros numatytosios reikšmės, galite išeiti iš klaidos pranešimo, jei parametras nėra nurodytas:

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

(Atkreipkite dėmesį į naudojimą : kaip nulinę komandą, kuri paprasčiausiai plečia savo argumentų reikšmes. Nenorime nieko daryti su $1 šiame pavyzdyje, tiesiog išeiti, jei nenustatyta)

14
01 февр. atsakymas pateikiamas chepner 01 Feb. 2012-02-01 01:05 '12 at 1:05 2012-02-01 01:05

Norėdami patikrinti, ar kintamasis nustatomas ne tuščia verte, naudokite [ -n "$x" ] , kaip kiti nurodė.

Daugeliu atvejų rekomenduojama keisti kintamąjį tuščiąja verte taip pat, kaip ir nenustatytą kintamąjį. Bet jūs galite atskirti du, jei jums reikia: [ -n "${x+set}" ] ( "${x+set}" plečiasi, jei set jei x nustatytas, ir tuščią eilutę, jei x nėra nustatytas).

Norėdami patikrinti, ar parametras buvo perduotas, išbandykite $# , kuris reiškia funkcijai perduotų parametrų skaičių (arba scenarijuje, jei ne funkcija) (žr. Atsakymą iš Pauliaus ).

12
31 авг. atsakymą pateikė Gilles 31 rug. 2010-08-31 10:30 '10 10:30 val. 2010-08-31 10:30

Bazėje galite naudoti -v viduje [[ ]] :

 #! /bin/bash -u if [[ ! -v SOMEVAR ]]; then SOMEVAR='hello' fi echo $SOMEVAR 
12
08 февр. atsakymas pateikiamas AlejandroVD 08 vasario 8 d. 2016-02-08 16:31 '16 at 16:31 2016-02-08 16:31

Tiems, kurie nori patikrinti, nėra iš naujo nustatomi , kai scenarijuje yra set -u :

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

Reguliarus [ -z "$var" ] neveiks su var; unbound variable var; unbound variable var; unbound variable var; unbound variable jei set -u bet [ -z "${var-}" ] išsiplečia į tuščią eilutę, jei var nėra įdiegtas nepavykus.

11
16 нояб. Atsakymą pateikė ekerulmas lapkričio 16 d. 2016-11-16 14:26 '16 at 14:26 pm 2016-11-16 14:26

Aukščiau pateikti atsakymai neveikia, jei įjungta „Bash set -u parinktis. Be to, jie nėra dinamiški, pavyzdžiui, kaip tikrinamas kintamasis „manekenas“? Pabandykite atlikti šiuos veiksmus:

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

Susiję: Kaip patikrinti „Bash“, kaip kintamasis yra nustatytas „-u“ režimu

4
09 нояб. atsakymą pateikė kevinarpe . 2013-11-09 11:55 '13, 11:55, 2013-11-09 11:55

Galite padaryti:

 function a { if [ ! -z "$1" ]; then echo '$1 is set' fi } 
4
30 авг. atsakymas, kurį pateikė codaddict Aug 30 2010-08-30 18:01 '10, 18:01, 2010-08-30 18:01

Jei var gali būti masyvas, parametro [ -z "${var+x}" ] yra neteisingas. Jei norite įsitikinti, kad Bash, turite naudoti masyvo sintaksę, pavyzdžiui, [ "${#var[@]}" = 0 ] , kaip parodyta žemiau.

 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 } 

Beveik visais atvejais jie sutinka. Vienintelė situacija, kai radau masyvo metodą, yra tikslesnis, kai kintamasis yra ne tuščias masyvas su 0 nulio padėtimi (pvz., 7 ir A bandymuose toliau). Šis neatitikimas atsiranda dėl to, kad $var yra ${var[0]} santrumpa, todėl [ -z "${var+x}" ] viso masyvo.

Čia yra mano testai:

 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 

Pateikiama išvada:

2
15 февр. Mark Haferkamp atsakymas, pateiktas vasario 15 d. 2016-02-15 17:32 '16 at 17:32 pm 2016-02-15 17:32

Naudojant [[ -z "$var" ]] yra lengviausias būdas sužinoti, ar kintamasis buvo nustatytas, ar ne, bet -z parinktis atskiria -z kintamąjį ir kintamąjį, nustatytą tuščią eilutę:

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

Geriausia tai patikrinti pagal kintamojo tipą: env kintamasis, parametras arba reguliarus kintamasis.

„Env“ kintamajam:

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

Parametrui (pvz., Norint patikrinti, ar yra parametras $5 ):

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

Dėl reguliaraus kintamojo (naudojant pagalbininko funkciją tai padaryti elegantiškai):

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

Pastabos:

  • $# : nurodo padėties parametrų skaičių.
  • declare -p : suteikia jums kintamo parametro apibrėžimą. Jei ji yra, grąžina 0, jei ne, grąžina 1 ir parodo klaidos pranešimą.
  • $? : nurodo paskutinės komandos būsenos kodą.
2
19 окт. atsakymas suteikiamas Peregring-lk spalio 19 d 2014-10-19 01:09 '14, 1:09 2014-10-19 01:09

Mano pageidaujamas metodas:

 $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 

Iš esmės, jei nustatomas kintamasis, jis tampa „gauto false neigimu“ (kuris bus nustatytas kaip true = ").

Ir jei jis nebus nustatytas, jis taps „rezultato true neigimu“ (kadangi tuščias rezultatas yra vertinamas kaip true ) (taigi jis baigiasi kaip false = „NEPILNAS“).

1
15 нояб. Atsakymas pateikiamas „ Aquarius Power“ 15 nov. 2014-11-15 20:55 '14, 20:55 2014-11-15 20:55

-z galite naudoti -z operatorių, kuris yra tiesa, jei eilutės ilgis yra nulis.

Paprastas vienos eilutės nustatymas numatytam MY_VAR , jei jis nėra įdiegtas, kitaip galite rodyti pranešimą:

 [[ -z "$MY_VAR" ]]  MY_VAR="default" [[ -z "$MY_VAR" ]]  MY_VAR="default" || echo "Variable already set." 
1
22 сент. atsakymas Kenorbui rugsėjo 22 d 2014-09-22 16:57 '14, 16:57, 2014-09-22 16:57
 if [[ ${!xx[@]} ]] ; then echo xx is defined; fi 
0
11 февр. Atsakymą pateikė Graham 11 vasaris 2015-02-11 23:51 '15 at 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 atsakymas pateikiamas solidsnack birželio 30 d. 13:22 2013-06-30 08:22

Nustatiau (daug) geresnį kodą, jei norite tai padaryti, jei norite ką nors patikrinti „ $@ .

 jei [[$ 1 = ""]] tada   aidas „$ 1 yra tuščias“ kitaip   aidas „$ 1 yra užpildytas“ fi

Kodėl visa tai? Viskas $@ egzistuoja Bash'e, bet pagal nutylėjimą ji yra tuščia, todėl test -z ir test -n negali jums padėti.

Atnaujinimas: Taip pat galite skaičiuoti simbolių skaičių parametruose.

 jei [$ {# 1} = 0] tada   aidas „$ 1 yra tuščias“ kitaip   aidas „$ 1 yra užpildytas“ fi
0
18 нояб. Atsakymas suteiktas Zlatanui 18 nov. 2013-11-18 17:44 '13, 17:44 2013-11-18 17:44

Visada naudoju šį metodą, atsižvelgiant į tai, kad lengva suprasti ką nors, kas pirmą kartą mato kodą:

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

Ir jei norite patikrinti, ar jis tuščias,

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

Kas tai yra.

0
07 сент. atsakymas duotas mijnnaam 07 sep . 2013-09-07 12:06 '13, 12:06, 2013-09-07 12:06

Tai, ką aš naudoju kiekvieną dieną:

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

Jis veikia gerai Linux ir Solaris prieš 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 дек. Atsakymas pateikiamas fr00tyl00p 11 gruodis. 2014-12-11 18:24 '14 at 18:24 2014-12-11 18:24
 (( ${#foo} )) 

arba

 declare -p foo 
0
11 мая '14 в 7:59 2014-05-11 07:59 Atsakymą pateikė Steven Penny gegužės 14 d. 14 val. 7:59 2014-05-11 07:59

Man patinka pagalbininko funkcijos paslėpti grubias detales. Šiuo atveju jis prideda dar daugiau (paslėptų) grubumo:

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

Kadangi pirmiausia turėjau klaidų įgyvendinant šį projektą (įkvėptas Jens ir Lionel atsakymų), aš atėjau kitą sprendimą:

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

Manau, kad tai paprastesnis, daugiau baskų ir lengviau suprasti / prisiminti. Bandymo atveju tai atitinka:

 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 

Be to, bandomasis atvejis rodo, kad local var NOT deklaruoja var (nebent sekate '='). Jau kurį laiką aš maniau, kad tokiu būdu paskelbiau kintamuosius, tik norėdami sužinoti dabar, kad ką tik išreiškiau savo ketinimą ... Manau, tai nėra op.

IsDeclared_Tricky xyz: 1
IsDeclared_Tricky foo: 1
IsDeclared_Tricky skydelis: 0
IsDeclared_Tricky baz: 0
IsDeclarated xyz: 1
IsDeclared foo: 1
Deklaruotas skydas: 0
Deklaruota baz: 0

BONUS: usecase

Šį bandymą dažniausiai naudoju parametrams (ir grąžinimui) funkcijoms šiek tiek „elegantiškai“ ir saugiai (beveik panašiai kaip sąsaja):

 #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 

Jei skambutis su visais reikalauja deklaruotų kintamųjų:

Sveikas pasaulis!

daugiau:

Klaida: kintamasis nėra deklaruotas: outputStr

-1
01 марта '16 в 16:12 2016-03-01 16:12 atsakymas duotas Danieliui S kovo 16 d. 16:12 2016-03-01 16:12

Jei norite patikrinti, ar kintamasis yra susietas ar nesusietas, tai gerai veikia net ir tada, kai įgalinote „nounset“ parinktį:

 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 atsakymą pateikė vartotojo1857592 gegužės 25 d., 13 d., 11:00 val. 2013-05-25 23:01

Funkcijos, skirtos patikrinti, ar kintamasis yra / išjungtas

įskaitant tuščią $array=()


Šios funkcijos tikrina, ar nurodytas pavadinimas yra kintamasis.

 # 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 вызывается только в том случае, если переменная не установлена ​​или пустой массив.