Я пишу скрипт bash, який має set -u, і у мене проблема з розширенням порожнього масиву: схоже, bash обробляє порожній масив як незмінену змінну під час розширення:

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

(теж declare -a arrне допомагає.)

Загальним рішенням цього є використання ${arr[@]-}замість цього, замінюючи таким чином порожній рядок замість ("невизначений") порожнього масиву. Однак це не є гарним рішенням, оскільки зараз ви не можете розрізнити між масивом з одним порожнім рядком і порожнім масивом. (@ -expansion є особливим у bash, він розширюється "${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.

Як видно з таблиці нижче, єдиним надійним розширенням для всіх сучасних версій 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[@]}"}жахливим. Якщо ви використовуєте довгі імена змінних масивів, це починає виглядати спагетті швидше, ніж зазвичай.

Спробуйте це замість цього:

$ 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 дуже прощає.

То чому Баш так ускладнив обробку крайової справи масивів? Зітхнути. Я не можу гарантувати, що версія дозволить подібне зловживання оператором зрізу масиву, але це працює для мене надзвичайно.

Застереження: я використовую 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, ми могли б сказати, що помилка є у самому визначенні ("набору") та / або в тому, що вона застосовується непослідовно. У попередньому абзаці на довідковій сторінці сказано

... ${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's (прийнято) та @ kevinarpe (також добре).

Ви можете "${arr[@]:+${arr[@]}}"вирішити проблему. Права сторона (тобто після:+ ) надає вираз, який буде використовуватися у випадку, якщо ліва сторона не визначена / нульова.

Синтаксис - загадковий. Зауважте, що права частина виразу зазнає розширення параметрів, тому слід звернути особливу увагу на послідовне цитування.

: 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, менш загадковим синтаксисом є використання позначення фрагмента масиву ${arr[@]:0}(у версіях Bash >= 4.4), яке розширюється до всіх параметрів, починаючи з індексу 0. Це також не вимагає стільки повторень. Це розширення працює незалежно від set -u, тому ви можете ним користуватися завжди. На сторінці користувача написано (під Розширенням параметрів ):

• ${parameter:offset}

• ${parameter:offset:length}

  ... Якщо параметр - це індексоване ім'я масиву, підписане @або *, результатом є довжина членів масиву, що починається з ${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[@]-}'"