Compruebe si la matriz está vacía en Bash

Tengo una matriz que se llena con diferentes mensajes de error a medida que se ejecuta mi script.

Necesito una forma de verificar si está vacío o no al final del script y tomar una acción específica si es así.

Ya he intentado tratarlo como un VAR normal y usar -z para verificarlo, pero eso no parece funcionar. ¿Hay alguna manera de verificar si una matriz está vacía o no en Bash?

Supongamos que su matriz es $errors, solo verifique si el recuento de elementos es cero.

if [ ${#errors[@]} -eq 0 ]; then
    echo "No errors, hooray"
else
    echo "Oops, something went wrong..."
fi

Generalmente uso la expansión aritmética en este caso:

if (( ${#a[@]} )); then
    echo not empty
fi

También puede considerar la matriz como una variable simple. De esa manera, solo usando

if [ -z "$array" ]; then
    echo "Array empty"
else
    echo "Array non empty"
fi

o usando el otro lado

if [ -n "$array" ]; then
    echo "Array non empty"
else
    echo "Array empty"
fi

El problema con esta solución es que si se declara una matriz de esta manera: array=('' foo). Estas comprobaciones informarán que la matriz está vacía, mientras que claramente no lo está. (¡Gracias @musiphil!)

Usando [ -z "$array[@]" ]claramente no es una solución ni. Al no especificar llaves se intenta interpretar $arraycomo una cadena ( [@]en ese caso, es una cadena literal simple) y, por lo tanto, siempre se informa como falsa: "¿está [@]vacía la cadena literal ?" Claramente no.

Lo comprobé con bash-4.4.0:

#!/usr/bin/env bash
set -eu
check() {
    if [[ ${array[@]} ]]; then
        echo not empty
    else
        echo empty
    fi
}
check   # empty
array=(a b c d)
check   # not empty
array=()
check   # empty

y bash-4.1.5:

#!/usr/bin/env bash
set -eu
check() {
    if [[ ${array[@]:+${array[@]}} ]]; then
        echo non-empty
    else
        echo empty
    fi
}
check   # empty
array=(a b c d)
check   # not empty
array=()
check   # empty

En el último caso, necesita la siguiente construcción:

${array[@]:+${array[@]}}

para que no falle en una matriz vacía o desarmada. Eso si haces lo set -euque yo suelo hacer. Esto proporciona una comprobación de errores más estricta. De los documentos :

-mi

Salga de inmediato si una tubería (vea Tuberías), que puede consistir en un solo comando simple (vea Comandos simples), una lista (vea Listas) o un comando compuesto (vea Comandos compuestos) devuelve un estado distinto de cero. El shell no sale si el comando que falla es parte de la lista de comandos inmediatamente después de un tiempo o hasta la palabra clave, parte de la prueba en una declaración if, parte de cualquier comando ejecutado en un && o || lista excepto el comando que sigue al && o || final, cualquier comando en una tubería pero el último, o si el estado de retorno del comando se invierte con!. Si un comando compuesto que no sea un subshell devuelve un estado distinto de cero porque un comando falló mientras se ignoraba -e, el shell no se cierra. Una trampa en ERR, si se establece, se ejecuta antes de que salga el shell.

Esta opción se aplica al entorno de shell y a cada entorno de subshell por separado (consulte Entorno de ejecución de comandos) y puede hacer que los subshells salgan antes de ejecutar todos los comandos en el subshell.

Si un comando compuesto o una función de shell se ejecuta en un contexto donde se ignora -e, ninguno de los comandos ejecutados dentro del comando compuesto o el cuerpo de la función se verá afectado por la configuración -e, incluso si se establece -e y un comando devuelve un estado de falla Si un comando compuesto o una función de shell establece -e mientras se ejecuta en un contexto donde se ignora -e, esa configuración no tendrá ningún efecto hasta que se complete el comando compuesto o el comando que contiene la llamada a la función.

-u

Trate las variables y parámetros no establecidos que no sean los parámetros especiales '@' o '*' como un error al realizar la expansión de parámetros. Se escribirá un mensaje de error en el error estándar y se cerrará un shell no interactivo.

Si no necesita eso, no dude en omitir :+${array[@]}parte.

También tenga en cuenta que es esencial usar el [[operador aquí, con lo [que obtiene:

$ cat 1.sh
#!/usr/bin/env bash
set -eu
array=(a b c d)
if [ "${array[@]}" ]; then
    echo non-empty
else
    echo empty
fi

$ ./1.sh
_/1.sh: line 4: [: too many arguments
empty

Si desea detectar una matriz con elementos vacíos ,arr=("" "") como vacío, igual quearr=()

Puede pegar todos los elementos juntos y verificar si el resultado es de longitud cero. (Construir una copia aplanada del contenido de la matriz no es ideal para el rendimiento si la matriz puede ser muy grande. Pero espero que no estés usando bash para programas como ese ...)

Pero se "${arr[*]}"expande con elementos separados por el primer carácter de IFS. Por lo tanto, debe guardar / restaurar IFS y hacer IFS=''que esto funcione, o bien comprobar que la longitud de la cadena == # de elementos de la matriz - 1. (Una matriz de nelementos tiene n-1separadores). Para lidiar con eso fuera de uno, es más fácil rellenar la concatenación en 1

arr=("" "")

## Assuming default non-empty IFS
## TODO: also check for ${#arr[@]} -eq 0
concat="${arr[*]} "      # n-1 separators + 1 space + array elements
[[ "${#concat}" -ne "${#arr[@]}" ]]  && echo not empty array || echo empty array

caso de prueba con set -x

### a non-empty element
$ arr=("" "x")
  + arr=("" "x")
$ concat="${arr[*]} ";  [[ "${#concat}" -ne "${#arr[@]}" ]] && echo not empty array || echo empty array
  + concat=' x '
  + [[ 3 -ne 2 ]]
  + echo not empty array
not empty array

### 2 empty elements
$ arr=("" "")
  + arr=("" "")
$ concat="${arr[*]} ";  [[ "${#concat}" -ne "${#arr[@]}" ]] && echo not empty array || echo empty array
  + concat='  '
  + [[ 2 -ne 2 ]]
  + echo empty array
empty array

Por desgracia, esta falla por arr=(): [[ 1 -ne 0 ]]. Por lo tanto, primero deberá verificar las matrices realmente vacías por separado.

O conIFS='' . Probablemente quiera guardar / restaurar IFS en lugar de usar una subshell, porque no puede obtener un resultado de una subshell fácilmente.

# inside a () subshell so we don't modify our own IFS
(IFS='' ; [[ -n "${arr[*]}" ]] && echo not empty array || echo empty array)

ejemplo:

$ arr=("" "")
$ (IFS='' ; [[ -n "${arr[*]}" ]] && echo not empty array || echo empty array)
   + IFS=
   + [[ -n '' ]]
   + echo empty array
empty array

no funciona con arr=()- sigue siendo sólo la cadena vacía.

En mi caso, la segunda respuesta no fue suficiente porque podría haber espacios en blanco. Llegué junto con:

if [ "$(echo -ne ${opts} | wc -m)" -eq 0 ]; then
  echo "No options"
else
  echo "Options found"
fi

Prefiero usar corchetes dobles:

if [[ !${array[@]} ]]
then
    echo "Array is empty"
else
    echo "Array is not empty"
fi

Paréntesis dobles: https://stackoverflow.com/questions/669452/is-preferable-over-in-bash