จะตรวจสอบว่าตัวแปรถูกตั้งค่าใน Bash ได้อย่างไร?

ฉันจะทราบได้อย่างไรว่าตัวแปรถูกตั้งค่าใน Bash หรือไม่

ตัวอย่างเช่นฉันจะตรวจสอบได้อย่างไรว่าผู้ใช้กำหนดพารามิเตอร์แรกให้กับฟังก์ชันหรือไม่

function a {
    # if $1 is set ?
}

(ปกติ) วิธีที่ถูกต้อง

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

โดยที่${var+x}การขยายพารามิเตอร์ซึ่งประเมินเป็นอะไรถ้าvarไม่ได้ตั้งค่าและแทนที่สตริงเป็นxอย่างอื่น

การพูดคำพูด

สามารถละเว้นเครื่องหมายอัญประกาศ(เพื่อให้เราสามารถพูด${var+x}แทนได้"${var+x}") เนื่องจากไวยากรณ์และการใช้งานนี้รับประกันได้ว่าจะขยายไปยังบางสิ่งที่ไม่จำเป็นต้องมีเครื่องหมายอัญประกาศเท่านั้น (เนื่องจากอาจขยายเป็นx(ซึ่งไม่มีการแบ่งคำ ไม่มีสิ่งใด (ซึ่งส่งผล[ -z ]ให้ประเมินสิ่งอำนวยความสะดวกให้เป็นค่าเดียวกัน (จริง) ที่[ -z "" ]ทำได้เช่นกัน)

อย่างไรก็ตามในขณะที่ราคาสามารถละเว้นได้อย่างปลอดภัยและมันก็ไม่ได้ชัดเจนทันทีที่ทุกคน (มันไม่ได้ชัดเจนแม้แต่กับผู้เขียนคนแรกของคำอธิบายคำพูดนี้ใครยังเป็น Bash coder ที่สำคัญ) บางครั้งมันจะดีกว่าที่จะเขียนทางออก ด้วยราคาที่เป็น[ -z "${var+x}" ]ไปได้ของการลงโทษความเร็ว O (1) น้อยมาก ผู้เขียนคนแรกยังเพิ่มสิ่งนี้เป็นความคิดเห็นถัดจากโค้ดโดยใช้วิธีแก้ปัญหานี้ซึ่งให้ URL ของคำตอบนี้ซึ่งในขณะนี้ยังมีคำอธิบายสำหรับสาเหตุที่สามารถละเว้นคำพูดได้อย่างปลอดภัย

(บ่อยครั้ง) วิธีที่ผิด

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

สิ่งนี้มักจะผิดเพราะมันไม่ได้แยกความแตกต่างระหว่างตัวแปรที่ไม่ได้ตั้งค่าและตัวแปรที่ถูกตั้งค่าเป็นสตริงว่าง กล่าวคือถ้าvar=''แก้ปัญหาข้างต้นจะส่งออก "var ว่างเปล่า"

ความแตกต่างระหว่าง unset และ "set to string ว่างเปล่า" เป็นสิ่งจำเป็นในสถานการณ์ที่ผู้ใช้ต้องระบุส่วนขยายหรือรายการคุณสมบัติเพิ่มเติมและไม่ได้ระบุค่าเริ่มต้นให้เป็นค่าที่ไม่ว่างเปล่าในขณะที่ระบุสตริงว่างควร ทำให้สคริปต์ใช้ส่วนขยายที่ว่างเปล่าหรือรายการคุณสมบัติเพิ่มเติม

ความแตกต่างอาจไม่จำเป็นในทุกสถานการณ์ ในกรณีเหล่านั้น [ -z "$var" ]จะไม่เป็นไร

ในการตรวจสอบตัวแปรสตริงที่ไม่เป็นนัล / ไม่เป็นศูนย์เช่นถ้าตั้งให้ใช้

if [ -n "$1" ]

-zมันตรงข้ามของ ฉันพบตัวเองโดยใช้มากกว่า-n-z

คุณจะใช้มันเหมือน:

if [ -n "$1" ]; then
  echo "You supplied the first parameter!"
else
  echo "First parameter not supplied."
fi

ต่อไปนี้เป็นวิธีทดสอบว่าพารามิเตอร์ไม่มีการตั้งค่าหรือว่างเปล่า ("Null")หรือตั้งค่าด้วยค่า :

+--------------------+----------------------+-----------------+-----------------+
|   Expression       |       parameter      |     parameter   |    parameter    |
|   in script:       |   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 |
+--------------------+----------------------+-----------------+-----------------+

ที่มา: POSIX: การขยายพารามิเตอร์ :

ในทุกกรณีที่แสดงด้วย "ทดแทน" นิพจน์จะถูกแทนที่ด้วยค่าที่แสดง ในทุกกรณีที่แสดงด้วย "assign" พารามิเตอร์จะถูกกำหนดค่านั้นซึ่งจะแทนที่นิพจน์

หากต้องการแสดงสิ่งนี้ให้ดำเนินการ:

+--------------------+----------------------+-----------------+-----------------+
|   Expression       |  FOO="world"         |     FOO=""      |    unset FOO    |
|   in script:       |  (Set and Not Null)  |  (Set But Null) |     (Unset)     |
+--------------------+----------------------+-----------------+-----------------+
| ${FOO:-hello}      | world                | hello           | hello           |
| ${FOO-hello}       | world                | ""              | hello           |
| ${FOO:=hello}      | world                | FOO=hello       | FOO=hello       |
| ${FOO=hello}       | world                | ""              | FOO=hello       |
| ${FOO:?hello}      | world                | error, exit     | error, exit     |
| ${FOO?hello}       | world                | ""              | error, exit     |
| ${FOO:+hello}      | hello                | ""              | ""              |
| ${FOO+hello}       | hello                | hello           | ""              |
+--------------------+----------------------+-----------------+-----------------+

แม้ว่าเทคนิคส่วนใหญ่ที่ระบุไว้ในที่นี้จะถูกต้อง แต่bash 4.2รองรับการทดสอบจริงสำหรับการปรากฏตัวของตัวแปร ( man bash ) แทนที่จะทดสอบค่าของตัวแปร

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

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

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

โดยเฉพาะอย่างยิ่งวิธีการนี้จะไม่ทำให้เกิดข้อผิดพลาดเมื่อนำมาใช้ในการตรวจสอบล้างค่าตัวแปรในset -u/ set -o nounsetโหมดซึ่งแตกต่างจากวิธีอื่น ๆ [ -zอีกมากมายเช่นการใช้

มีหลายวิธีในการทำเช่นนี้โดยการเป็นหนึ่งในนั้น:

if [ -z "$1" ]

สิ่งนี้จะสำเร็จถ้า $ 1 เป็นโมฆะหรือไม่มีการตั้งค่า

ฉันมักจะพบตาราง POSIX ในคำตอบอื่น ๆช้าไป grok ดังนั้นนี่คือของฉันใช้มัน:

   +----------------------+------------+-----------------------+-----------------------+
   |   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")
• emptyหมายถึงVARIABLEempty / null ( VARIABLE="")
• unsetหมายถึงVARIABLEไม่มีอยู่ ( unset VARIABLE)

ค่า:

• $VARIABLE หมายความว่าผลลัพธ์คือค่าดั้งเดิมของตัวแปร
• "default" หมายความว่าผลลัพธ์เป็นสตริงการแทนที่ที่จัดเตรียมไว้
• "" หมายความว่าผลลัพธ์เป็นโมฆะ (สตริงว่าง)
• exit 127 หมายความว่าสคริปต์หยุดทำงานด้วยรหัสออก 127
• $(VARIABLE="default")หมายความว่าผลลัพธ์คือค่าดั้งเดิมของตัวแปรและสตริงการแทนที่ที่ระบุถูกกำหนดให้กับตัวแปรสำหรับใช้ในอนาคต

เพื่อดูว่าตัวแปรไม่ว่างเปล่าฉันใช้

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

การทดสอบตรงข้ามถ้าตัวแปรไม่ได้ตั้งค่าหรือว่างเปล่า:

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

เพื่อดูว่ามีการตั้งค่าตัวแปร (ว่างหรือไม่ว่าง) ฉันใช้

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

ในเวอร์ชันที่ทันสมัยของ Bash (ฉันคิดว่า 4.2 ขึ้นไปฉันไม่รู้แน่) ฉันจะลองทำสิ่งนี้:

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

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

ถึงแม้ว่าสำหรับข้อโต้แย้งมันเป็นสิ่งที่ดีที่สุดในการทดสอบ $ # ซึ่งเป็นจำนวนข้อโต้แย้งในความคิดของฉัน

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

บันทึก

ฉันให้คำตอบที่เน้นแรงมากเพราะbashแท็ก

คำตอบสั้น ๆ

ตราบใดที่คุณจัดการกับตัวแปรที่มีชื่อใน Bash ฟังก์ชันนี้ควรจะบอกคุณเสมอว่าตัวแปรนั้นถูกตั้งค่าไว้หรือไม่แม้ว่ามันจะเป็นอาร์เรย์ที่ว่างเปล่าก็ตาม

variable-is-set() {
    declare -p "$1" &>/dev/null
}

ทำไมถึงใช้งานได้

ใน Bash (อย่างน้อยที่สุดกลับมาที่ 3.0) หากvarเป็นตัวแปรที่ประกาศ / ตั้งค่าจะdeclare -p varแสดงdeclareคำสั่งที่จะตั้งค่าตัวแปรvarตามชนิดและค่าปัจจุบันของมันและส่งคืนรหัสสถานะ0(สำเร็จ) ถ้าvarจะไม่ได้ประกาศแล้วdeclare -p varแสดงข้อความแสดงข้อผิดพลาดไปและรหัสสถานะผลตอบแทนstderr 1ใช้&>/dev/null, เปลี่ยนทิศทางทั้งปกติstdoutและstderrส่งออกไป/dev/nullเป็นไม่เคยเห็นและไม่มีการเปลี่ยนรหัสสถานะ ดังนั้นฟังก์ชั่นจะส่งคืนรหัสสถานะเท่านั้น

สาเหตุที่วิธีการอื่น (บางครั้ง) ล้มเหลวใน Bash

• [ -n "$var" ]:สิ่งนี้จะตรวจสอบว่า${var[0]}ไม่มีข้อมูลหรือไม่ (ใน Bash $varเป็นเช่นเดียวกับ${var[0]}.)
• [ -n "${var+x}" ]:สิ่งนี้จะตรวจสอบว่า${var[0]}มีการตั้งค่าหรือไม่
• [ "${#var[@]}" != 0 ]:สิ่งนี้จะตรวจสอบว่า$varมีการตั้งค่าอย่างน้อยหนึ่งดัชนี

เมื่อวิธีนี้ล้มเหลวใน Bash

นี้จะทำงานเฉพาะสำหรับตัวแปรชื่อ (รวม$_) ตัวแปรพิเศษไม่แน่ใจ ( $!, $@, $#, $$, $*, $?, $-, $0, $1, $2, ... , และที่ฉันอาจจะลืม) เนื่องจากไม่มีสิ่งเหล่านี้เป็นอาร์เรย์สไตล์ POSIX จึงใช้[ -n "${var+x}" ]งานได้กับตัวแปรพิเศษเหล่านี้ทั้งหมด แต่ระวังการห่อไว้ในฟังก์ชั่นเนื่องจากตัวแปรพิเศษจำนวนมากเปลี่ยนค่า / การดำรงอยู่เมื่อเรียกใช้ฟังก์ชั่น

บันทึกการทำงานร่วมกันของเชลล์

ถ้าสคริปต์ของคุณมีอาร์เรย์และคุณกำลังพยายามที่จะทำให้มันเข้ากันได้กับเปลือกหอยให้มากที่สุดเท่าที่เป็นไปได้แล้วพิจารณาใช้แทนtypeset -p declare -pฉันอ่านแล้วว่า ksh รองรับเฉพาะรุ่นก่อนหน้า แต่ไม่สามารถทดสอบได้ ฉันรู้ว่า Bash 3.0+ และ Zsh 5.5.1 แต่ละตัวรองรับทั้งคู่typeset -pและdeclare -pต่างกันเพียงอันเดียวที่เป็นตัวเลือกสำหรับอีกอันหนึ่ง แต่ฉันไม่ได้ทดสอบความแตกต่างจากคำหลักสองคำเหล่านั้นและฉันยังไม่ได้ทดสอบเชลล์อื่น ๆ

หากคุณต้องการให้สคริปต์ของคุณใช้งานร่วมกับ POSIX ได้คุณจะไม่สามารถใช้อาร์เรย์ได้ โดยไม่ต้องอาร์เรย์[ -n "{$var+x}" ]ทำงาน

รหัสเปรียบเทียบสำหรับวิธีการต่างๆใน Bash

ฟังก์ชั่นนี้จะยกเลิกการตั้งค่าตัวแปรvarซึ่งevalเป็นรหัสที่ผ่านแล้วทำการทดสอบเพื่อตรวจสอบว่าvarมีการตั้งค่าด้วยevalรหัส d หรือไม่และสุดท้ายจะแสดงรหัสสถานะที่ได้สำหรับการทดสอบที่แตกต่างกัน

ฉันกระโดดข้ามtest -v var, [ -v var ]และ[[ -v var ]]เพราะพวกเขาให้ผลลัพธ์ที่เหมือนกันกับมาตรฐาน POSIX [ -n "${var+x}" ]ในขณะที่ต้องทุบตีเวอร์ชัน 4.2 ขึ้นไป ฉันยังข้ามtypeset -pเพราะมันเหมือนกับdeclare -pเชลล์ที่ฉันทดสอบ (Bash 3.0 ถึง 5.0 และ Zsh 5.5.1)

is-var-set-after() {
    # Set var by passed expression.
    unset var
    eval "$1"

    # Run the tests, in increasing order of accuracy.
    [ -n "$var" ] # (index 0 of) var is nonempty
    nonempty=$?
    [ -n "${var+x}" ] # (index 0 of) var is set, maybe empty
    plus=$?
    [ "${#var[@]}" != 0 ] # var has at least one index set, maybe empty
    count=$?
    declare -p var &>/dev/null # var has been declared (any type)
    declared=$?

    # Show test results.
    printf '%30s: %2s %2s %2s %2s\n' "$1" $nonempty $plus $count $declared
}

รหัสกรณีทดสอบ

โปรดทราบว่าผลการทดสอบอาจไม่คาดคิดเนื่องจาก Bash ใช้ดัชนีอาร์เรย์ที่ไม่ใช่ตัวเลขเป็น "0" หากตัวแปรไม่ได้ถูกประกาศเป็นอาร์เรย์ที่เชื่อมโยง นอกจากนี้อาร์เรย์ที่เชื่อมโยงจะใช้ได้ใน Bash 4.0+ เท่านั้น

# Header.
printf '%30s: %2s %2s %2s %2s\n' "test" '-n' '+x' '#@' '-p'
# First 5 tests: Equivalent to setting 'var=foo' because index 0 of an
# indexed array is also the nonindexed value, and non-numerical
# indices in an array not declared as associative are the same as
# index 0.
is-var-set-after "var=foo"                        #  0  0  0  0
is-var-set-after "var=(foo)"                      #  0  0  0  0
is-var-set-after "var=([0]=foo)"                  #  0  0  0  0
is-var-set-after "var=([x]=foo)"                  #  0  0  0  0
is-var-set-after "var=([y]=bar [x]=foo)"          #  0  0  0  0
# '[ -n "$var" ]' fails when var is empty.
is-var-set-after "var=''"                         #  1  0  0  0
is-var-set-after "var=([0]='')"                   #  1  0  0  0
# Indices other than 0 are not detected by '[ -n "$var" ]' or by
# '[ -n "${var+x}" ]'.
is-var-set-after "var=([1]='')"                   #  1  1  0  0
is-var-set-after "var=([1]=foo)"                  #  1  1  0  0
is-var-set-after "declare -A var; var=([x]=foo)"  #  1  1  0  0
# Empty arrays are only detected by 'declare -p'.
is-var-set-after "var=()"                         #  1  1  1  0
is-var-set-after "declare -a var"                 #  1  1  1  0
is-var-set-after "declare -A var"                 #  1  1  1  0
# If 'var' is unset, then it even fails the 'declare -p var' test.
is-var-set-after "unset var"                      #  1  1  1  1

ทดสอบผลลัพธ์

จำการทดสอบในตรงส่วนหัวแถว[ -n "$var" ], [ -n "${var+x}" ], [ "${#var[@]}" != 0 ]และdeclare -p varตามลำดับ

                         test: -n +x #@ -p
                      var=foo:  0  0  0  0
                    var=(foo):  0  0  0  0
                var=([0]=foo):  0  0  0  0
                var=([x]=foo):  0  0  0  0
        var=([y]=bar [x]=foo):  0  0  0  0
                       var='':  1  0  0  0
                 var=([0]=''):  1  0  0  0
                 var=([1]=''):  1  1  0  0
                var=([1]=foo):  1  1  0  0
declare -A var; var=([x]=foo):  1  1  0  0
                       var=():  1  1  1  0
               declare -a var:  1  1  1  0
               declare -A var:  1  1  1  0
                    unset var:  1  1  1  1

สรุป

• declare -p var &>/dev/null (100%) น่าเชื่อถือสำหรับการทดสอบตัวแปรที่มีชื่อใน Bash ตั้งแต่อย่างน้อย 3.0
• [ -n "${var+x}" ] เชื่อถือได้ในสถานการณ์ที่สอดคล้องกับ POSIX แต่ไม่สามารถจัดการอาร์เรย์ได้
• มีการทดสอบอื่นเพื่อตรวจสอบว่าตัวแปรไม่ว่างเปล่าหรือไม่และตรวจสอบตัวแปรที่ประกาศในเชลล์อื่น ๆ แต่การทดสอบเหล่านี้เหมาะสำหรับสคริปต์ Bash หรือ POSIX

สำหรับผู้ที่ต้องการตรวจสอบว่าไม่มีการกำหนดหรือว่างเปล่าเมื่ออยู่ในสคริปต์ด้วย set -u:

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

การ[ -z "$var" ]ตรวจสอบปกติจะล้มเหลวvar; unbound variableหากset -uแต่[ -z "${var-}" ] ขยายเป็นสตริงว่างถ้าvarไม่ได้ตั้งค่าโดยไม่ล้มเหลว

คุณต้องการออกหากยังไม่ได้ตั้งค่า

สิ่งนี้ใช้ได้สำหรับฉัน ฉันต้องการให้สคริปต์ของฉันออกจากพร้อมข้อความแสดงข้อผิดพลาดหากไม่ได้ตั้งค่าพารามิเตอร์

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

สิ่งนี้จะส่งคืนพร้อมข้อผิดพลาดเมื่อเรียกใช้

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

ตรวจสอบเท่านั้นไม่มีทางออก - ว่างเปล่าและไม่ได้ตั้งค่าเป็นไม่ถูกต้อง

ลองใช้ตัวเลือกนี้ถ้าคุณเพียงต้องการตรวจสอบว่าค่า set = VALID หรือ 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

หรือแม้กระทั่งการทดสอบสั้น ๆ ;-)

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

ตรวจสอบเท่านั้นไม่มีทางออก - ว่างเปล่าเท่านั้นคือไม่ถูกต้อง

และนี่คือคำตอบของคำถาม ใช้สิ่งนี้หากคุณต้องการตรวจสอบว่าค่า set / empty = 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

ในการตรวจสอบว่าตัวแปรถูกตั้งค่าด้วยค่าที่ไม่ว่างหรือไม่ให้ใช้[ -n "$x" ]ตามที่คนอื่น ๆ ระบุไว้แล้ว

ส่วนใหญ่แล้วมันเป็นความคิดที่ดีที่จะจัดการกับตัวแปรที่มีค่าว่างในแบบเดียวกับตัวแปรที่ไม่ได้ตั้งค่า แต่คุณสามารถแยกความแตกต่างระหว่างสองสิ่งนี้ได้หากคุณต้องการ: [ -n "${x+set}" ]( "${x+set}"ขยายเป็นsetหากxตั้งค่าและเป็นสตริงว่างถ้าxไม่ได้ตั้งค่า)

ในการตรวจสอบว่าพารามิเตอร์ผ่านการทดสอบ$#หรือไม่ซึ่งเป็นจำนวนพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชัน (หรือไปยังสคริปต์เมื่อไม่ได้อยู่ในฟังก์ชัน) (ดูคำตอบของ Paul )

อ่านส่วน "การขยายพารามิเตอร์" ของbashหน้า man การขยายพารามิเตอร์ไม่ได้ให้การทดสอบทั่วไปสำหรับตัวแปรที่กำลังตั้งค่า แต่มีหลายสิ่งที่คุณสามารถทำได้กับพารามิเตอร์หากยังไม่ได้ตั้งค่า

ตัวอย่างเช่น:

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
}

(โปรดสังเกตว่าการใช้:คำสั่ง null ซึ่งเพิ่งขยายค่าของอาร์กิวเมนต์เราไม่ต้องการทำอะไรกับ$1ในตัวอย่างนี้เพียงแค่ออกหากไม่ได้ตั้งค่าไว้)

ในทุบตีคุณสามารถใช้ -vภายใน[[ ]]builtin:

#! /bin/bash -u

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

echo $SOMEVAR

การใช้[[ -z "$var" ]]เป็นวิธีที่ง่ายที่สุดที่จะทราบว่าตัวแปรถูกตั้งค่าหรือไม่ แต่ตัวเลือก-zนั้นไม่แยกความแตกต่างระหว่างตัวแปรที่ไม่ได้ตั้งค่าและตัวแปรที่ตั้งค่าเป็นสตริงว่าง:

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

ควรตรวจสอบตามประเภทของตัวแปร: ตัวแปร env, พารามิเตอร์หรือตัวแปรปกติ

สำหรับตัวแปร 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
}
declare_var "var_name" && echo "Set" || echo "Unset"

หมายเหตุ:

• $#:ช่วยให้คุณจำนวนพารามิเตอร์ตำแหน่ง
• declare -p:ให้นิยามของตัวแปรที่ส่งผ่านเป็นพารามิเตอร์ หากมีอยู่ให้ส่งคืน 0 ถ้าไม่ส่งคืน 1 และพิมพ์ข้อความแสดงข้อผิดพลาด
• &> /dev/null:ระงับเอาต์พุตจากdeclare -pโดยไม่มีผลกระทบกับโค้ดส่งคืน

คำตอบข้างต้นไม่ทำงานเมื่อset -uเปิดใช้งานตัวเลือก Bash นอกจากนี้ยังไม่มีการเปลี่ยนแปลงเช่นจะกำหนดตัวแปรด้วยชื่อ "จำลอง" ได้อย่างไร ลองสิ่งนี้:

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

ที่เกี่ยวข้อง: ใน Bash ฉันจะทดสอบได้อย่างไรว่าตัวแปรถูกกำหนดในโหมด "-u"

คุณทำได้:

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

วิธีที่ฉันชอบคือ:

$ var=10
$ if ! ${var+false};then echo "is set";else echo "NOT set";fi
is set
$ unset -v var
$ if ! ${var+false};then echo "is set";else echo "NOT set";fi
NOT set

โดยพื้นฐานแล้วหากตั้งค่าตัวแปรมันจะกลายเป็น "การปฏิเสธของผลลัพธ์false" (สิ่งที่จะเป็นtrue = "ถูกตั้งค่า")

และหากไม่ได้ตั้งค่ามันจะกลายเป็น "การปฏิเสธของผลลัพธ์true" (เมื่อผลลัพธ์ว่างเปล่าประเมินเป็นtrue) (ดังนั้นจะสิ้นสุดเป็นfalse= "ไม่ได้ตั้งค่า")

[[ $foo ]]

หรือ

(( ${#foo} ))

หรือ

let ${#foo}

หรือ

declare -p foo

ในเชลล์คุณสามารถใช้-zโอเปอเรเตอร์ซึ่งเป็น True หากความยาวของสตริงเป็นศูนย์

ซับในแบบง่ายเพื่อตั้งค่าเริ่มต้นMY_VARหากยังไม่ได้ตั้งค่ามิฉะนั้นคุณสามารถแสดงข้อความได้:

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

if [[ ${1:+isset} ]]
then echo "It was set and not null." >&2
else echo "It was not set or it was null." >&2
fi

if [[ ${1+isset} ]]
then echo "It was set but might be null." >&2
else echo "It was was not set." >&2
fi

ผมพบว่า (มาก) $@รหัสดีกว่าที่จะทำเช่นนี้หากคุณต้องการที่จะตรวจสอบอะไรใน

ถ้า [[1 $ = ""]]
แล้วก็
  echo '$ 1 ว่างเปล่า'
อื่น
  echo '$ 1 เต็มแล้ว'
Fi

ทำไมทั้งหมดนี้ ทุกอย่างใน$@ที่มีอยู่ในทุบตี แต่โดยปกติก็ว่างเปล่าดังนั้นtest -zและtest -nไม่สามารถช่วยคุณ

อัปเดต:คุณยังสามารถนับจำนวนอักขระในพารามิเตอร์

ถ้า [$ {# 1} = 0]
แล้วก็
  echo '$ 1 ว่างเปล่า'
อื่น
  echo '$ 1 เต็มแล้ว'
Fi

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

นี่คือสิ่งที่ฉันใช้ทุกวัน:

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

สิ่งนี้ทำงานได้ดีภายใต้ Linux และ Solaris จนถึง 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

ฉันชอบฟังก์ชั่นเสริมเพื่อซ่อนรายละเอียดที่หยาบของ bash ในกรณีนี้การทำเช่นนั้นจะเพิ่มความหยาบ (ซ่อนเร้น) ให้มากขึ้น:

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

เนื่องจากฉันมีข้อบกพร่องในการใช้งานครั้งแรก (ได้รับแรงบันดาลใจจากคำตอบของ Jens และ Lionel) ฉันจึงคิดวิธีแก้ปัญหาที่แตกต่างกัน:

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

ฉันคิดว่ามันจะตรงไปตรงมามากขึ้น bashy และง่ายต่อการเข้าใจ / จำ กรณีทดสอบแสดงให้เห็นว่ามันเทียบเท่า:

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

กรณีการทดสอบยังแสดงให้เห็นว่าlocal varไม่ไม่ประกาศ var (เว้นแต่ตามด้วย '=') สำหรับบางครั้งที่ฉันคิดว่าฉันประกาศตัวแปรด้วยวิธีนี้เพียงเพื่อค้นพบตอนนี้ที่ฉันเพียงแสดงความตั้งใจของฉัน ... มันเป็นไม่มี -op ฉันเดา

IsDeclared_Tricky xyz: 1
foo IsDeclared_Tricky: 1
IsDeclared_Tricky บาร์: 0
IsDeclared_Tricky baz: 0
IsDeclared xyz: 1
foo IsDeclared: 1
บาร์ IsDeclared: 0
baz IsDeclared: 0

โบนัส: usecase

ฉันส่วนใหญ่ใช้การทดสอบนี้เพื่อให้ (และกลับ) พารามิเตอร์การทำงานในค่อนข้าง "สง่างาม" และวิธีที่ปลอดภัย (เกือบคล้ายอินเทอร์เฟซ ... ):

#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

หากเรียกด้วยตัวแปรทั้งหมดจะต้องมีการประกาศ:

สวัสดีชาวโลก!

อื่น:

ข้อผิดพลาด: ไม่ได้ประกาศตัวแปร: outputStr

หลังจากอ่านคำตอบทั้งหมดแล้วก็สามารถใช้งานได้:

if [[ -z $SOME_VAR ]]; then read -p "Enter a value for SOME_VAR: " SOME_VAR; fi
echo "SOME_VAR=$SOME_VAR"

หากคุณไม่ใส่SOME_VARแทนสิ่งที่ฉันมี$SOME_VARมันจะตั้งเป็นค่าว่าง $จำเป็นสำหรับสิ่งนี้ในการทำงาน

เพื่อตรวจสอบว่ามีการตั้งค่า var หรือไม่

var=""; [[ $var ]] && echo "set" || echo "not set"

หากคุณต้องการทดสอบว่าตัวแปรถูกผูกไว้หรือไม่ถูกผูกมัดสิ่งนี้จะทำงานได้ดีแม้หลังจากที่คุณเปิดใช้งานตัวเลือกคำนาม:

set -o noun set

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

ฉันมักจะใช้อันนี้ตามความจริงที่ว่าทุกคนที่เห็นรหัสเป็นเรื่องง่ายที่จะเข้าใจได้ง่าย:

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

และหากต้องการตรวจสอบว่าไม่ว่างเปล่า

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

แค่นั้นแหละ.