bash - बैश में एक चर सेट किया गया है या नहीं?




shell variables (20)

Functions to check if variable is declared/unset

including empty $array=()


The following functions test if the given name exists as a 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;} 
}
  • By first testing if the variable is (un)set, the call to declare can be avoided, if not necessary.
  • If however $1 contains the name of an empty $array=() , the call to declare would make sure we get the right result
  • There's never much data passed to /dev/null as declare is only called if either the variable is unset or an empty array.

This functions would test as showed in the following conditions:

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

For more details

and a test script see my answer to the question "How do I check if a variable exists in bash?"

टिप्पणी: इसी तरह के उपयोग declare -p, जैसा कि के answer द्वारा भी दिखाया गया है , वास्तव में संयोग है। अन्यथा मैं निश्चित रूप से इसे श्रेय दिया होगा!

मुझे कैसे पता चलेगा कि बैश में एक चर सेट है या नहीं?

उदाहरण के लिए, मैं कैसे जांचूं कि उपयोगकर्ता ने फ़ंक्शन में पहला पैरामीटर दिया है या नहीं?

function a {
    # if $1 is set ?
}

अगर यह अनसेट हो तो आप बाहर निकलना चाहते हैं

यह मेरे लिए काम किया। यदि पैरामीटर सेट नहीं किया गया था, तो मैं चाहता था कि मेरी स्क्रिप्ट एक त्रुटि संदेश से बाहर निकलें।

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

यह चलने पर त्रुटि के साथ आता है

[email protected]:~$ ./setver.sh
./setver.sh: line 13: 1: You must pass a version of the format 0.0.0 as the only argument

केवल जांचें, कोई बाहर निकलें - खाली और अनसेट इनवॉलिड हैं

इस विकल्प को आजमाएं यदि आप सिर्फ यह जांचना चाहते हैं कि मान सेट = VALID या अनसेट / खाली = 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

या, यहां तक ​​कि छोटे परीक्षण ;-)

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

केवल जांचें, कोई बाहर निकलें - केवल खाली है INVALID

और यह सवाल का जवाब है। इसका उपयोग करें यदि आप सिर्फ यह जांचना चाहते हैं कि मान सेट / खाली = VALID या unset = INVALID है या नहीं।

नोट, "..- 1}" में "1" महत्वहीन है, यह कुछ भी हो सकता है (जैसे 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

लघु परीक्षण

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

मैं इस जवाब को @ mklement0 (टिप्पणियों) को समर्पित करता हूं जिन्होंने मुझे प्रश्न का सही जवाब देने के लिए चुनौती दी।

संदर्भ http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_02


उनमें से एक होने के साथ ऐसा करने के कई तरीके हैं:

if [ -z "$1" ]

यह सफल होता है अगर $ 1 शून्य या अनसेट है


एक खोल में आप -z ऑपरेटर का उपयोग कर सकते हैं जो सही है यदि स्ट्रिंग की लंबाई शून्य है।

यदि यह सेट नहीं है तो डिफ़ॉल्ट MY_VAR सेट करने के लिए एक साधारण एक-लाइनर, अन्यथा वैकल्पिक रूप से आप संदेश प्रदर्शित कर सकते हैं:

[[ -z "$MY_VAR" ]] && MY_VAR="default"
[[ -z "$MY_VAR" ]] && MY_VAR="default" || echo "Variable already set."

तुम कर सकते हो:

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

बाश में आप [[ ]] अंतर्निहित के अंदर -v उपयोग कर सकते हैं:

#! /bin/bash -u

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

echo $SOMEVAR

बैश विकल्प set -u सक्षम होने पर ऊपर दिए गए उत्तर काम नहीं करते हैं। इसके अलावा, वे गतिशील नहीं हैं, उदाहरण के लिए, परीक्षण करने के लिए कैसे परिवर्तनीय है "डमी" नाम परिभाषित किया गया है? इसे इस्तेमाल करे:

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

संबंधित: बैश में, यदि मैं "-u" मोड में एक चर परिभाषित किया गया है, तो मैं कैसे परीक्षण करूं?


मेरा पसंदीदा तरीका यह है:

$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

तो मूल रूप से, यदि एक चर सेट किया गया है, तो यह "परिणामी false की अस्वीकृति" बन जाता है ( true क्या होगा = "सेट है")।

और, यदि यह सेट नहीं होता है, तो यह "परिणामी true की अस्वीकृति" बन जाएगा (जैसे खाली परिणाम true मूल्यांकन करता true ) (इसलिए false होने के रूप में समाप्त होगा = "सेट नहीं")।


मैं यही हर दिन उपयोग करता हूं:

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

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

मैं हमेशा दूसरे जवाब में POSIX तालिका को ग्रोक करने में धीमा करता हूं, इसलिए यहां मेरा लेना है:

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

ध्यान दें कि प्रत्येक समूह (पहले और बिना कॉलन के) में एक ही सेट होता है और मामलों को अनसेट करता है, इसलिए केवल एक चीज जो अलग होती है वह है कि रिक्त मामलों को कैसे नियंत्रित किया जाता है।

पिछले कॉलन के साथ, खाली और अनसेट केस समान हैं, इसलिए मैं उन लोगों का उपयोग करूंगा जहां संभव हो (यानी उपयोग करें := , न केवल = , क्योंकि खाली मामला असंगत है)।

शीर्षक:

  • सेट का अर्थ है VARIABLE गैर-खाली है ( VARIABLE="something" )
  • खाली साधन VARIABLE खाली / शून्य है ( VARIABLE="" )
  • अनसेट का अर्थ है VARIABLE मौजूद नहीं है ( unset VARIABLE )

मान:

  • $VARIABLE मतलब है कि परिणाम $VARIABLE का मूल मान है।
  • "default" मतलब है कि परिणाम प्रतिस्थापन स्ट्रिंग प्रदान किया गया था।
  • "" मतलब है नतीजा शून्य है (एक खाली स्ट्रिंग)।
  • exit 127 अर्थ है स्क्रिप्ट निकास कोड 127 के साथ निष्पादित करना बंद कर देता है।
  • $(VARIABLE="default") अर्थ है कि परिणाम परिवर्तनीय का मूल मान है और प्रदान किए गए प्रतिस्थापन स्ट्रिंग को भविष्य के उपयोग के लिए चर को असाइन किया गया है।

यदि आप [email protected] में कुछ भी देखना चाहते हैं तो मुझे ऐसा करने के लिए एक (बहुत) बेहतर कोड मिला।

if [[ $1 = "" ]]
then
  echo '$1 is blank'
else
  echo '$1 is filled up'
fi

यह सब क्यों? [email protected] में सबकुछ बैश में मौजूद है, लेकिन डिफ़ॉल्ट रूप से यह खाली है, इसलिए test -z और test -n आपकी मदद नहीं कर सका।

अद्यतन: आप पैरामीटर में वर्णों की संख्या भी गिन सकते हैं।

if [ ${#1} = 0 ]
then
  echo '$1 is blank'
else
  echo '$1 is filled up'
fi

यह जांचने का तरीका बताया गया है कि कोई पैरामीटर अनसेट है या खाली है ("शून्य") या मान के साथ सेट करें :

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

स्रोत: पॉज़िक्स: पैरामीटर विस्तार :

"विकल्प" के साथ दिखाए गए सभी मामलों में, अभिव्यक्ति को दिखाए गए मान के साथ बदल दिया गया है। "असाइन" के साथ दिखाए गए सभी मामलों में, पैरामीटर उस मान को असाइन किया गया है, जो अभिव्यक्ति को भी बदल देता है।


यह देखने के लिए कि कोई चर अपरिवर्तनीय है, मैं उपयोग करता हूं

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

विपरीत परीक्षण यदि एक चर या तो अनसेट या खाली है:

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

यह देखने के लिए कि कोई चर सेट है (खाली या nonempty), मैं उपयोग करता हूं

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

यदि कोई चर सेट न हो तो विपरीत परीक्षण:

if [[ ! ${var+x} ]]; then ... # `var' is not set at all
if [[ ! ${1+x} ]]; then ...   # We were called with no arguments

हालांकि यहां बताई गई अधिकांश तकनीकों में सही हैं, बैश 4.2 वैरिएबल के मान का परीक्षण करने के बजाय एक चर ( मैन बैश ) की उपस्थिति के लिए वास्तविक परीक्षण का समर्थन करता है।

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

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

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

[[ -z "$var" ]] का उपयोग करना यह जानने का सबसे आसान तरीका है कि कोई चर सेट किया गया था या नहीं, लेकिन वह विकल्प -z एक अनसेट चर के बीच अंतर नहीं करता है, और एक चर सेट को खाली स्ट्रिंग पर सेट करता है:

 set=''

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

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

चर के प्रकार के अनुसार इसे जांचना सबसे अच्छा है: env चर, पैरामीटर या नियमित चर।

एक एनवी परिवर्तनीय के लिए:

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

पैरामीटर के लिए (उदाहरण के लिए, पैरामीटर "$ 5" के अस्तित्व की जांच करने के लिए:

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

एक नियमित चर के लिए (एक परिचित समारोह का उपयोग करके, इसे एक सुरुचिपूर्ण तरीके से करने के लिए):

function declare_var {
   declare -p "$1" &> /dev/null

   return $?
}

declare_var "var_name" && echo "Set" || echo "Unset"

टिप्पणियाँ:

$#                  says you the number of positional parameters.

declare -p          gives you the definition of the variable passed as parameter. If it 
                    exists, returns 0, if not, returns 1 and prints an error message.

$?                  gives you the status code of the last executed command.

bash मैन पेज के "पैरामीटर विस्तार" खंड को पढ़ें। पैरामीटर विस्तार एक परिवर्तनीय सेट के लिए एक सामान्य परीक्षण प्रदान नहीं करता है, लेकिन यदि सेट नहीं है तो पैरामीटर पर आप कई चीजें कर सकते हैं।

उदाहरण के लिए:

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

अगर इसे असाइन किया गया है तो first_arg को $1 बराबर सेट करेगा, अन्यथा यह "foo" मान का उपयोग करेगा। यदि a बिल्कुल एक पैरामीटर लेना चाहिए, और कोई अच्छा डिफ़ॉल्ट मौजूद नहीं है, तो कोई पैरामीटर नहीं दिए जाने पर आप एक त्रुटि संदेश से बाहर निकल सकते हैं:

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

(इसका उपयोग नोट करें : एक नल कमांड के रूप में, जो सिर्फ अपने तर्कों के मूल्यों का विस्तार करता है। हम इस उदाहरण में $1 साथ कुछ भी नहीं करना चाहते हैं, अगर यह सेट नहीं है तो बाहर निकलें)


If you wish to test that a variable is bound or unbound, this works well, even after you've turned on the nounset option:

set -o noun set

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

[[ $foo ]]

या

(( ${#foo} ))

या

let ${#foo}

या

declare -p foo

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

यद्यपि तर्कों के लिए आमतौर पर $ 81 का परीक्षण करना सर्वोत्तम होता है, जो कि मेरी राय में तर्कों की संख्या है।

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

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







variables