ฉันกำลังเขียนสคริปต์ bash ซึ่งมีset -uและฉันมีปัญหากับการขยายอาร์เรย์ที่ว่างเปล่า: bash ดูเหมือนจะถือว่าอาร์เรย์ว่างเป็นตัวแปรที่ไม่ได้ตั้งค่าระหว่างการขยาย:

$ set -u
$ arr=()
$ echo "foo: '${arr[@]}'"
bash: arr[@]: unbound variable

( declare -a arrไม่ช่วยเช่นกัน)

วิธีแก้ปัญหาทั่วไปสำหรับสิ่งนี้คือการใช้${arr[@]-}แทนดังนั้นการแทนที่สตริงว่างแทนที่จะเป็นอาร์เรย์ว่าง ("ไม่ได้กำหนด") อย่างไรก็ตามนี่ไม่ใช่วิธีแก้ปัญหาที่ดีเนื่องจากตอนนี้คุณไม่สามารถแยกแยะระหว่างอาร์เรย์ที่มีสตริงว่างเดียวกับอาร์เรย์ว่างได้ (@ - การขยายเป็นพิเศษในการทุบตีมันขยายออก"${arr[@]}"ไป"${arr[0]}" "${arr[1]}" …ซึ่งทำให้เป็นเครื่องมือที่สมบูรณ์แบบสำหรับการสร้างบรรทัดคำสั่ง)

$ countArgs() { echo $#; }
$ countArgs a b c
3
$ countArgs
0
$ countArgs ""
1
$ brr=("")
$ countArgs "${brr[@]}"
1
$ countArgs "${arr[@]-}"
1
$ countArgs "${arr[@]}"
bash: arr[@]: unbound variable
$ set +u
$ countArgs "${arr[@]}"
0

ดังนั้นมีวิธีแก้ปัญหานั้นไหมนอกเหนือจากการตรวจสอบความยาวของอาร์เรย์ในif(ดูตัวอย่างโค้ดด้านล่าง) หรือปิด-uการตั้งค่าสำหรับส่วนสั้น ๆ นั้น?

if [ "${#arr[@]}" = 0 ]; then
   veryLongCommandLine
else
   veryLongCommandLine "${arr[@]}"
fi

อัปเดต:bugsแท็กถูกลบเนื่องจากคำอธิบายของ ikegami

เพียงสำนวนที่ปลอดภัย${arr[@]+"${arr[@]}"}

นี่เป็นคำแนะนำในคำตอบของ ikegamiอยู่แล้ว แต่มีข้อมูลที่ผิดและการคาดเดามากมายในชุดข้อความนี้ รูปแบบอื่น ๆ เช่น${arr[@]-}หรือ${arr[@]:0}มีความไม่ปลอดภัยทั่วทั้งรุ่นใหญ่ของทุบตี

ดังตารางด้านล่างแสดงให้เห็นว่าส่วนขยายเดียวที่เชื่อถือได้ในเวอร์ชัน Bash ที่ทันสมัยทั้งหมดคือ${arr[@]+"${arr[@]}"}(คอลัมน์+") ข้อสังเกตการขยายอื่น ๆ อีกหลายรายการล้มเหลวใน Bash 4.2 รวมถึง (น่าเสียดาย) ${arr[@]:0}สำนวนที่สั้นกว่าซึ่งไม่เพียงให้ผลลัพธ์ที่ไม่ถูกต้อง แต่ล้มเหลวจริง หากคุณต้องการรองรับเวอร์ชันก่อน 4.4 และโดยเฉพาะอย่างยิ่ง 4.2 นี่เป็นสำนวนเดียวที่ใช้งานได้

น่าเสียดายที่+การขยายอื่น ๆที่เมื่อมองอย่างรวดเร็วดูเหมือนว่าจะทำให้เกิดพฤติกรรมที่แตกต่างกันออกไป :+การขยายไม่ปลอดภัยเนื่องจาก:-expansionถือว่าอาร์เรย์ที่มีองค์ประกอบว่างเดียว ( ('')) เป็น "null" ดังนั้นจึงไม่ (สม่ำเสมอ) ขยายเป็นผลลัพธ์เดียวกัน

การอ้างถึงการขยายแบบเต็มแทนที่จะเป็นอาร์เรย์ที่ซ้อนกัน ( "${arr[@]+${arr[@]}}") ซึ่งฉันคาดว่าจะเทียบเท่าโดยประมาณนั้นไม่ปลอดภัยเช่นเดียวกันใน 4.2

คุณสามารถดูรหัสที่สร้างข้อมูลนี้พร้อมกับผลลัพธ์ของ bash เวอร์ชันเพิ่มเติมหลายรายการได้ในส่วนสำคัญนี้

ตามเอกสารประกอบ

ตัวแปรอาร์เรย์ถือเป็นชุดหากมีการกำหนดค่าตัวห้อย สตริงว่างเป็นค่าที่ถูกต้อง

ไม่มีการกำหนดค่าตัวห้อยดังนั้นจึงไม่ได้ตั้งค่าอาร์เรย์

แต่ในขณะที่เอกสารที่แสดงให้เห็นข้อผิดพลาดมีความเหมาะสมที่นี่นี้จะไม่มีอีกต่อไปกรณีตั้งแต่ 4.4

$ bash --version | head -n 1
GNU bash, version 4.4.19(1)-release (x86_64-pc-linux-gnu)

$ set -u

$ arr=()

$ echo "foo: '${arr[@]}'"
foo: ''

การใช้งาน: มีเงื่อนไขที่คุณสามารถใช้แบบอินไลน์เพื่อให้บรรลุสิ่งที่คุณต้องการในรุ่นเก่าเป็นแทน${arr[@]+"${arr[@]}"}"${arr[@]}"

$ function args { perl -E'say 0+@ARGV; say "$_: $ARGV[$_]" for 0..$#ARGV' -- "$@" ; }

$ set -u

$ arr=()

$ args "${arr[@]}"
-bash: arr[@]: unbound variable

$ args ${arr[@]+"${arr[@]}"}
0

$ arr=("")

$ args ${arr[@]+"${arr[@]}"}
1
0: 

$ arr=(a b c)

$ args ${arr[@]+"${arr[@]}"}
3
0: a
1: b
2: c

ทดสอบด้วย bash 4.2.25 และ 4.3.11

คำตอบที่ยอมรับของ @ ikegami ผิดอย่างละเอียด! คาถาที่ถูกต้องคือ${arr[@]+"${arr[@]}"}:

$ countArgs () { echo "$#"; }
$ arr=('')
$ countArgs "${arr[@]:+${arr[@]}}"
0   # WRONG
$ countArgs ${arr[@]+"${arr[@]}"}
1   # RIGHT
$ arr=()
$ countArgs ${arr[@]+"${arr[@]}"}
0   # Let's make sure it still works for the other case...

ปรากฎว่ามีการเปลี่ยนแปลงการจัดการอาร์เรย์ในการเปิดตัวเมื่อเร็ว ๆ นี้ (2016/09/16) bash 4.4 (มีให้ใน Debian stretch เป็นต้น)

$ bash --version | head -n1
bash --version | head -n1
GNU bash, version 4.4.0(1)-release (x86_64-pc-linux-gnu)

ตอนนี้การขยายอาร์เรย์ว่างเปล่าไม่ส่งเสียงเตือน

$ set -u
$ arr=()
$ echo "${arr[@]}"

$ # everything is fine

นี่อาจเป็นอีกทางเลือกหนึ่งสำหรับผู้ที่ไม่ต้องการทำซ้ำ arr [@] และสามารถใช้สตริงว่างได้

echo "foo: '${arr[@]:-}'"

ทดสอบ:

set -u
arr=()
echo a "${arr[@]:-}" b # note two spaces between a and b
for f in a "${arr[@]:-}" b; do echo $f; done # note blank line between a and b
arr=(1 2)
echo a "${arr[@]:-}" b
for f in a "${arr[@]:-}" b; do echo $f; done

คำตอบของ @ ikegami ถูกต้อง แต่ฉันคิดว่าไวยากรณ์${arr[@]+"${arr[@]}"}น่ากลัว หากคุณใช้ชื่อตัวแปรอาร์เรย์แบบยาวมันจะเริ่มดู spaghetti-ish เร็วกว่าปกติ

ลองสิ่งนี้แทน:

$ set -u

$ count() { echo $# ; } ; count x y z
3

$ count() { echo $# ; } ; arr=() ; count "${arr[@]}"
-bash: abc[@]: unbound variable

$ count() { echo $# ; } ; arr=() ; count "${arr[@]:0}"
0

$ count() { echo $# ; } ; arr=(x y z) ; count "${arr[@]:0}"
3

ดูเหมือนว่าตัวดำเนินการ Bash array slice จะให้อภัยมาก

แล้วทำไม Bash ถึงจัดการเคสขอบของอาร์เรย์ได้ยากขนาดนี้? เฮ้อ. ฉันไม่สามารถรับประกันได้ว่าเวอร์ชันของคุณจะอนุญาตให้ใช้ตัวดำเนินการส่วนอาร์เรย์ในทางที่ผิด แต่มันก็ใช้งานได้ดีสำหรับฉัน

ข้อแม้: ฉันใช้GNU bash, version 3.2.25(1)-release (x86_64-redhat-linux-gnu) ไมล์สะสมของคุณอาจแตกต่างกันไป

ความไม่ลงรอยกัน "น่าสนใจ" แน่นอน

นอกจากนี้

$ set -u
$ echo $#
0
$ echo "$1"
bash: $1: unbound variable   # makes sense (I didn't set any)
$ echo "$@" | cat -e
$                            # blank line, no error

แม้ว่าฉันจะยอมรับว่าพฤติกรรมในปัจจุบันอาจไม่ใช่ข้อบกพร่องตามที่ @ikegami อธิบาย แต่ IMO เราสามารถพูดได้ว่าจุดบกพร่องนั้นอยู่ในคำจำกัดความ (ของ "set") เองและ / หรือความจริงที่ว่ามันถูกนำไปใช้อย่างไม่สอดคล้องกัน ย่อหน้าก่อนหน้าในหน้าคนพูดว่า

... ${name[@]}ขยายแต่ละองค์ประกอบของชื่อเป็นคำแยกกัน เมื่อไม่มีสมาชิกอาร์เรย์ให้${name[@]}ขยายเป็นอะไรเลย

ซึ่งสอดคล้องอย่างสิ้นเชิงกับสิ่งที่กล่าวเกี่ยวกับการขยายพารามิเตอร์ตำแหน่งใน"$@". ไม่ใช่ว่าไม่มีความไม่สอดคล้องกันอื่น ๆ ในพฤติกรรมของอาร์เรย์และพารามิเตอร์ตำแหน่ง ... แต่สำหรับฉันแล้วไม่มีคำใบ้ว่ารายละเอียดนี้ควรไม่สอดคล้องกันระหว่างทั้งสอง

ดำเนินการต่อ

$ arr=()
$ echo "${arr[@]}"
bash: arr[@]: unbound variable   # as we've observed.  BUT...
$ echo "${#arr[@]}"
0                                # no error
$ echo "${!arr[@]}" | cat -e
$                                # no error

ดังนั้นarr[]ไม่ได้เป็นเช่นนั้นไม่ได้ผูกไว้ว่าเราไม่สามารถได้รับการนับจำนวนขององค์ประกอบของมัน (0) หรือ (ว่าง) รายการคีย์ของมันหรือไม่? สำหรับฉันสิ่งเหล่านี้สมเหตุสมผลและมีประโยชน์ - สิ่งเดียวที่ดูเหมือนจะเป็นการขยาย${arr[@]}(และ${arr[*]})

ฉันกำลังเสริมคำตอบของ@ ikegami (ยอมรับ) และ@ kevinarpe (ก็ดีด้วย)

คุณสามารถ"${arr[@]:+${arr[@]}}"แก้ไขปัญหาได้ ด้านขวามือ (เช่นหลัง:+) จัดเตรียมนิพจน์ที่จะใช้ในกรณีที่ไม่ได้กำหนดด้านซ้ายมือ / null

ไวยากรณ์เป็นอาร์เคน โปรดทราบว่าทางด้านขวามือของนิพจน์จะมีการขยายพารามิเตอร์ดังนั้นควรให้ความสนใจเป็นพิเศษกับการอ้างถึงที่สอดคล้องกัน

: example copy arr into arr_copy
arr=( "1 2" "3" )
arr_copy=( "${arr[@]:+${arr[@]}}" ) # good. same quoting. 
                                    # preserves spaces

arr_copy=( ${arr[@]:+"${arr[@]}"} ) # bad. quoting only on RHS.
                                    # copy will have ["1","2","3"],
                                    # instead of ["1 2", "3"]

เช่นเดียวกับที่ @kevinarpe กล่าวถึงไวยากรณ์ arcane ที่น้อยกว่าคือการใช้สัญกรณ์อาร์เรย์สไลซ์${arr[@]:0}(ในเวอร์ชัน Bash >= 4.4) ซึ่งขยายไปยังพารามิเตอร์ทั้งหมดโดยเริ่มจากดัชนี 0 นอกจากนี้ยังไม่ต้องการการทำซ้ำมากนัก ส่วนขยายนี้ใช้งานได้โดยไม่คำนึงถึงset -uดังนั้นคุณสามารถใช้สิ่งนี้ได้ตลอดเวลา หน้าคนพูดว่า (ภายใต้การขยายพารามิเตอร์ ):

• ${parameter:offset}

• ${parameter:offset:length}

  ... ถ้าพารามิเตอร์เป็นชื่ออาร์เรย์จัดทำดัชนี subscripted โดย@หรือผลที่ได้เป็นสมาชิกระยะเวลาของการเริ่มต้นกับอาร์เรย์* ${parameter[offset]}ค่าชดเชยเชิงลบถูกนำมาเทียบกับค่าหนึ่งที่มากกว่าดัชนีสูงสุดของอาร์เรย์ที่ระบุ เป็นข้อผิดพลาดในการขยายหากความยาวประเมินเป็นตัวเลขที่น้อยกว่าศูนย์

นี่คือตัวอย่างที่จัดทำโดย @kevinarpe โดยมีการจัดรูปแบบอื่นเพื่อวางเอาต์พุตในหลักฐาน:

set -u
function count() { echo $# ; };
(
    count x y z
)
: prints "3"

(
    arr=()
    count "${arr[@]}"
)
: prints "-bash: arr[@]: unbound variable"

(
    arr=()
    count "${arr[@]:0}"
)
: prints "0"

(
    arr=(x y z)
    count "${arr[@]:0}"
)
: prints "3"

ลักษณะการทำงานนี้แตกต่างกันไปตามเวอร์ชันของ Bash คุณอาจสังเกตเห็นว่าตัวดำเนินการความยาว${#arr[@]}จะประเมินเป็น0อาร์เรย์ว่างเสมอโดยไม่คำนึงถึงset -uโดยไม่ก่อให้เกิด 'ข้อผิดพลาดของตัวแปรที่ไม่ถูกผูกไว้'

ต่อไปนี้เป็นสองวิธีในการทำสิ่งนี้วิธีหนึ่งโดยใช้ทหารรักษาการณ์และอีกวิธีหนึ่งโดยใช้เงื่อนไขต่อท้าย:

#!/bin/bash
set -o nounset -o errexit -o pipefail
countArgs () { echo "$#"; }

arrA=( sentinel )
arrB=( sentinel "{1..5}" "./*" "with spaces" )
arrC=( sentinel '$PWD' )
cmnd=( countArgs "${arrA[@]:1}" "${arrB[@]:1}" "${arrC[@]:1}" )
echo "${cmnd[@]}"
"${cmnd[@]}"

arrA=( )
arrB=( "{1..5}" "./*"  "with spaces" )
arrC=( '$PWD' )
cmnd=( countArgs )
# Checks expansion of indices.
[[ ! ${!arrA[@]} ]] || cmnd+=( "${arrA[@]}" )
[[ ! ${!arrB[@]} ]] || cmnd+=( "${arrB[@]}" )
[[ ! ${!arrC[@]} ]] || cmnd+=( "${arrC[@]}" )
echo "${cmnd[@]}"
"${cmnd[@]}"

ความไม่สอดคล้องที่น่าสนใจ; สิ่งนี้ช่วยให้คุณสามารถกำหนดสิ่งที่ "ไม่ถือว่าเป็นชุด" แต่ยังปรากฏในผลลัพธ์ของdeclare -p

arr=()
set -o nounset
echo ${arr[@]}
 =>  -bash: arr[@]: unbound variable
declare -p arr
 =>  declare -a arr='()'

อัปเดต: ตามที่คนอื่นกล่าวถึงแก้ไขใน 4.4 ที่เผยแพร่หลังจากโพสต์คำตอบนี้

วิธีที่ง่ายที่สุดและเข้ากันได้น่าจะเป็น:

$ set -u
$ arr=()
$ echo "foo: '${arr[@]-}'"