Estoy escribiendo un script de bash que tiene set -u, y tengo un problema con la expansión de matriz vacía: bash parece tratar una matriz vacía como una variable no configurada durante la expansión:

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

( declare -a arrtampoco ayuda)

Una solución común a esto es usar ${arr[@]-}en su lugar, sustituyendo así una cadena vacía en lugar de la matriz vacía ("indefinida"). Sin embargo, esta no es una buena solución, ya que ahora no puede distinguir entre una matriz con una sola cadena vacía y una matriz vacía. (@ -Ampliación es especial en bash, se expande "${arr[@]}"en "${arr[0]}" "${arr[1]}" …, lo que hace que sea una herramienta perfecta para la construcción de líneas 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

Entonces, ¿hay alguna forma de solucionar ese problema, además de verificar la longitud de una matriz en un if(ver ejemplo de código a continuación), o desactivar la -uconfiguración para esa pieza corta?

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

Actualización:bugs etiqueta eliminada debido a la explicación de ikegami.

El único modismo seguro es${arr[@]+"${arr[@]}"}

Esta ya es la recomendación en la respuesta de ikegami , pero hay mucha información errónea y conjeturas en este hilo. Otros patrones, como ${arr[@]-}o ${arr[@]:0}, no son seguros en todas las versiones principales de Bash.

Como muestra la siguiente tabla, la única expansión que es confiable en todas las versiones modernas de Bash es ${arr[@]+"${arr[@]}"}(columna +"). Es de destacar que varias otras expansiones fallan en Bash 4.2, incluido (desafortunadamente) el ${arr[@]:0}modismo más corto , que no solo produce un resultado incorrecto sino que en realidad falla. Si necesita admitir versiones anteriores a la 4.4, y en particular a la 4.2, este es el único idioma que funciona.

Desafortunadamente, otras +expansiones que, a simple vista, parecen iguales, emiten un comportamiento diferente. :+la expansión no es segura, porque :-expansion trata una matriz con un solo elemento vacío ( ('')) como "nulo" y, por lo tanto, no se expande (consistentemente) al mismo resultado.

Citar la expansión completa en lugar de la matriz anidada ( "${arr[@]+${arr[@]}}"), que habría esperado que fuera aproximadamente equivalente, es igualmente inseguro en 4.2.

Puede ver el código que generó estos datos junto con los resultados de varias versiones adicionales de bash en esta esencia .

Según la documentación,

Una variable de matriz se considera establecida si a un subíndice se le ha asignado un valor. La cadena nula es un valor válido.

No se ha asignado un valor a ningún subíndice, por lo que la matriz no está configurada.

Pero aunque la documentación sugiere que aquí es apropiado un error, este ya no es el caso desde 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: ''

Hay un condicional que puede usar en línea para lograr lo que desea en versiones anteriores: use en ${arr[@]+"${arr[@]}"}lugar 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

Probado con bash 4.2.25 y 4.3.11.

¡La respuesta aceptada de @ikegami es sutilmente incorrecta! El encantamiento correcto es ${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...

Resulta que el manejo de matrices ha sido cambiado en bash 4.4 recientemente lanzado (2016/09/16) (disponible en Debian stretch, por ejemplo).

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

Ahora la expansión de matrices vacías no emite advertencia

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

$ # everything is fine

esta puede ser otra opción para aquellos que prefieren no duplicar arr [@] y están bien tener una cadena vacía

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

Probar:

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

La respuesta de @ikegami es correcta, pero considero que la sintaxis es ${arr[@]+"${arr[@]}"}terrible. Si usa nombres de variables de matriz largos, comenzará a verse más rápido de lo habitual.

Prueba esto en su lugar:

$ 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 el operador de corte de matriz Bash es muy indulgente.

Entonces, ¿por qué Bash hizo que el manejo del caso extremo de las matrices fuera tan difícil? Suspiro. No puedo garantizar que su versión permita tal abuso del operador de corte de matriz, pero funciona a la perfección para mí.

Advertencia: estoy usando GNU bash, version 3.2.25(1)-release (x86_64-redhat-linux-gnu) Su kilometraje puede variar.

Incoherencia "interesante" de hecho.

Además,

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

Si bien estoy de acuerdo en que el comportamiento actual puede no ser un error en el sentido que explica @ikegami, en mi opinión podríamos decir que el error está en la definición (de "conjunto") en sí, y / o en el hecho de que se aplica de manera inconsistente. El párrafo anterior en la página del manual dice

... ${name[@]}expande cada elemento del nombre a una palabra separada. Cuando no hay miembros de la matriz, se ${name[@]}expande a nada.

que es totalmente coherente con lo que dice sobre la expansión de los parámetros posicionales en "$@". No es que no haya otras inconsistencias en el comportamiento de las matrices y los parámetros posicionales ... pero para mí no hay indicios de que este detalle deba ser inconsistente entre los dos.

Continuo,

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

Entonces, arr[]¿no es tan independiente que no podemos obtener un recuento de sus elementos (0) o una lista (vacía) de sus claves? Para mí, estos son razonables y útiles; el único valor atípico parece ser la ${arr[@]}(y ${arr[*]}) expansión.

Estoy complementando las respuestas de @ ikegami (aceptadas) y de @ kevinarpe (también buenas).

Puede hacer "${arr[@]:+${arr[@]}}"para solucionar el problema. El lado derecho (es decir, después :+) proporciona una expresión que se utilizará en caso de que el lado izquierdo no esté definido / nulo.

La sintaxis es misteriosa. Tenga en cuenta que el lado derecho de la expresión sufrirá una expansión de parámetros, por lo que se debe prestar especial atención a tener citas 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 menciona @kevinarpe, una sintaxis menos arcana es usar la notación de corte de matriz ${arr[@]:0}(en las versiones Bash >= 4.4), que se expande a todos los parámetros, comenzando desde el índice 0. Tampoco requiere tanta repetición. Esta expansión funciona independientemente de set -u, por lo que puede usarla en todo momento. La página del manual dice (en Expansión de parámetros ):

• ${parameter:offset}

• ${parameter:offset:length}

  ... Si el parámetro es un nombre de matriz indexado subindicado por @o *, el resultado son los miembros de longitud de la matriz que comienzan con ${parameter[offset]}. Se toma un desplazamiento negativo relativo a uno mayor que el índice máximo de la matriz especificada. Es un error de expansión si la longitud se evalúa como un número menor que cero.

Este es el ejemplo proporcionado por @kevinarpe, con formato alternativo para poner la salida en evidencia:

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"

Este comportamiento varía con las versiones de Bash. También puede haber notado que el operador de longitud ${#arr[@]}siempre evaluará 0para matrices vacías, independientemente de set -u, sin causar un 'error de variable no vinculada'.

Aquí hay un par de formas de hacer algo como esto, una usando centinelas y otra usando anexos condicionales:

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

Incoherencia interesante; esto le permite definir algo que "no se considera configurado" pero que aparece en la salida dedeclare -p

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

ACTUALIZACIÓN: como mencionaron otros, se corrigió en 4.4 lanzado después de que se publicó esta respuesta.

La forma más sencilla y compatible parece ser:

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