Estou escrevendo um script bash que tem set -u, e tenho um problema com a expansão da matriz vazia: o bash parece tratar uma matriz vazia como uma variável não definida durante a expansão:

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

( declare -a arrtambém não ajuda.)

Uma solução comum para isso é usar em ${arr[@]-}vez disso, substituindo assim uma string vazia em vez do array vazio ("indefinido"). No entanto, esta não é uma boa solução, pois agora você não pode discernir entre um array com uma única string vazia e um array vazio. (@ -expansion é especial no bash, ele se expande "${arr[@]}"para "${arr[0]}" "${arr[1]}" …, o que o torna uma ferramenta perfeita para construir linhas de comando.)

$ 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

Portanto, há uma maneira de contornar esse problema, além de verificar o comprimento de uma matriz em um if(veja o exemplo de código abaixo), ou desativar a -uconfiguração para esse pequeno pedaço?

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

Atualização:bugs Tag removida devido à explicação de ikegami.

O único idioma seguro é${arr[@]+"${arr[@]}"}

Esta já é a recomendação na resposta de ikegami , mas há muita desinformação e suposições neste tópico. Outros padrões, como ${arr[@]-}ou ${arr[@]:0}, não são seguros em todas as versões principais do Bash.

Como mostra a tabela abaixo, a única expansão confiável em todas as versões modernas do Bash é ${arr[@]+"${arr[@]}"}(coluna +"). É importante notar que várias outras expansões falham no Bash 4.2, incluindo (infelizmente) o ${arr[@]:0}idioma mais curto , que não apenas produz um resultado incorreto, mas também falha. Se você precisa oferecer suporte a versões anteriores a 4.4 e, em particular, 4.2, este é o único idioma funcional.

Infelizmente outro + expansões que, à primeira vista, parecem iguais, de fato emitem comportamentos diferentes. :+a expansão não é segura, porque :-expansion trata uma matriz com um único elemento vazio ( ('')) como "nulo" e, portanto, não se expande (de forma consistente) para o mesmo resultado.

Citar a expansão completa em vez do array aninhado ( "${arr[@]+${arr[@]}}"), que eu esperava ser aproximadamente equivalente, é igualmente inseguro em 4.2.

Você pode ver o código que gerou esses dados junto com os resultados de várias versões adicionais do bash nesta essência .

De acordo com a documentação,

Uma variável de matriz é considerada definida se um valor subscrito foi atribuído. A string nula é um valor válido.

Nenhum subscrito foi atribuído a um valor, então a matriz não está definida.

Mas, embora a documentação sugira que um erro é apropriado aqui, esse não é mais o caso desde o 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: ''

Há uma condição que você pode usar embutida para conseguir o que deseja nas versões anteriores: Use em ${arr[@]+"${arr[@]}"}vez de "${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

Testado com bash 4.2.25 e 4.3.11.

A resposta aceita de @ikegami está sutilmente errada! O encantamento correto é ${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...

Acontece que o manuseio do array foi alterado no recentemente lançado (2016/09/16) bash 4.4 (disponível no Debian stretch, por exemplo).

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

Agora, a expansão de matrizes vazias não emite aviso

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

$ # everything is fine

esta pode ser outra opção para aqueles que preferem não duplicar arr [@] e estão bem em ter uma string vazia

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

testar:

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

A resposta de @ikegami está correta, mas considero a sintaxe ${arr[@]+"${arr[@]}"}terrível. Se você usar nomes de variáveis ​​de matriz longa, começa a parecer espaguete mais rápido do que o normal.

Em vez disso, tente isto:

$ 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

Parece que o operador de fatia da matriz Bash é muito complacente.

Então, por que Bash dificultou tanto o tratamento do caso extremo dos arrays? Suspiro. Não posso garantir que sua versão permitirá tal abuso do operador de fatia de array, mas funciona muito bem para mim.

Advertência: Estou usando GNU bash, version 3.2.25(1)-release (x86_64-redhat-linux-gnu) sua milhagem pode variar.

De fato, inconsistência "interessante".

Além disso,

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

Embora eu concorde que o comportamento atual pode não ser um bug no sentido que @ikegami explica, IMO podemos dizer que o bug está na definição (de "set") em si, e / ou no fato de que é aplicado de forma inconsistente. O parágrafo anterior na página de manual diz

... ${name[@]}expande cada elemento do nome para uma palavra separada. Quando não há membros da matriz, se ${name[@]}expande para nada.

o que é inteiramente consistente com o que diz sobre a expansão dos parâmetros posicionais em "$@". Não que não haja outras inconsistências nos comportamentos de matrizes e parâmetros posicionais ... mas para mim não há indícios de que esse detalhe seja inconsistente entre os dois.

Continuando,

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

Portanto, arr[]não é tão desvinculado que não podemos obter uma contagem de seus elementos (0) ou uma lista (vazia) de suas chaves? Para mim, eles são sensatos e úteis - o único valor atípico parece ser o${arr[@]} (e ${arr[*]}) expansão.

Estou complementando no @ ikegami (aceito) e no @kevinarpe (também bom).

Você pode fazer "${arr[@]:+${arr[@]}}"para contornar o problema. O lado direito (ou seja, depois:+ ) fornece uma expressão que será usada caso o lado esquerdo não seja definido / nulo.

A sintaxe é misteriosa. Observe que o lado direito da expressão sofrerá expansão de parâmetros, portanto, atenção extra deve ser dada para ter citações consistentes.

: 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"]

Como @kevinarpe menciona, uma sintaxe menos misteriosa é usar a notação de fatia de array ${arr[@]:0}(nas versões Bash >= 4.4), que se expande para todos os parâmetros, começando do índice 0. Também não requer tanta repetição. Essa expansão funciona independentemente set -u, então você pode usar isso a qualquer momento. A página do manual diz (em Expansão de parâmetro ):

• ${parameter:offset}

• ${parameter:offset:length}

  ... Se o parâmetro for um nome de matriz indexado com subscrito por @ou *, o resultado será o comprimento dos membros da matriz começando com ${parameter[offset]}. Um deslocamento negativo é obtido em relação a um maior que o índice máximo da matriz especificada. É um erro de expansão se o comprimento for avaliado como um número menor que zero.

Este é o exemplo fornecido por @kevinarpe, com formatação alternativa para colocar a saída em evidência:

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"

Esse comportamento varia com as versões do Bash. Você também deve ter notado que o operador de comprimento ${#arr[@]}sempre avaliará como 0para matrizes vazias, independentemente de set -u, sem causar um 'erro de variável não acoplada'.

Aqui estão algumas maneiras de fazer algo assim, uma usando sentinelas e outra usando anexos condicionais:

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

Inconsistência interessante; isso permite que você defina algo que "não é considerado definido", mas aparece na saída dedeclare -p

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

ATUALIZAÇÃO: conforme outros mencionados, corrigido no 4.4 divulgado após a publicação desta resposta.

A forma mais simples e compatível parece ser:

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