Controlla se l'array è vuoto in Bash

Ho un array che viene riempito con diversi messaggi di errore durante l'esecuzione del mio script.

Ho bisogno di un modo per verificare se è vuoto o non alla fine dello script e, se lo è, intraprendere un'azione specifica.

Ho già provato a trattarlo come un normale VAR e usando -z per controllarlo, ma non sembra funzionare. C'è un modo per verificare se un array è vuoto o no in Bash?

Supponendo che l'array sia $errors, basta controllare per vedere se il conteggio degli elementi è zero.

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

In genere utilizzo l'espansione aritmetica in questo caso:

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

Puoi anche considerare l'array come una semplice variabile. In questo modo, basta usare

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

o usando l'altro lato

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

Il problema con questa soluzione è che se una matrice è dichiarato in questo modo: array=('' foo). Questi controlli segnaleranno l'array come vuoto, mentre chiaramente non lo è. (grazie @musiphil!)

L'uso non [ -z "$array[@]" ]è chiaramente una soluzione né. Non specificando le parentesi graffe si cerca di interpretare $arraycome una stringa ( [@]è in quel caso una semplice stringa letterale) e viene quindi sempre indicata come falsa: "la stringa letterale è [@]vuota?" Chiaramente no.

L'ho controllato 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

e 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

In quest'ultimo caso è necessario il seguente costrutto:

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

affinché non fallisca sull'array vuoto o non impostato. Questo è se fai set -eucome faccio di solito. Ciò consente un controllo degli errori più rigoroso. Dai documenti :

-e

Esci immediatamente se una pipeline (vedi Pipeline), che può consistere in un singolo comando semplice (vedi Comandi semplici), un elenco (vedi Elenchi) o un comando composto (vedi Comandi composti) restituisce uno stato diverso da zero. La shell non si chiude se il comando che fallisce fa parte dell'elenco dei comandi immediatamente dopo un po 'o fino alla parola chiave, parte del test in un'istruzione if, parte di qualsiasi comando eseguito in un && o || list tranne il comando che segue l'ultimo && o ||, qualsiasi comando in una pipeline tranne l'ultimo, o se lo stato di ritorno del comando viene invertito con!. Se un comando composto diverso da una subshell restituisce uno stato diverso da zero perché un comando ha avuto esito negativo mentre -e veniva ignorato, la shell non esce. Una trap su ERR, se impostata, viene eseguita prima della chiusura della shell.

Questa opzione si applica all'ambiente shell e a ciascun ambiente subshell separatamente (consultare Ambiente di esecuzione comandi) e può causare la chiusura delle subshell prima di eseguire tutti i comandi nella subshell.

Se un comando composto o una funzione shell viene eseguita in un contesto in cui -e viene ignorato, nessuno dei comandi eseguiti all'interno del comando composto o del corpo della funzione sarà influenzato dall'impostazione -e, anche se -e è impostato e un comando restituisce un stato di errore. Se un comando composto o una funzione shell imposta -e durante l'esecuzione in un contesto in cui -e viene ignorato, tale impostazione non avrà alcun effetto fino al completamento del comando composto o del comando contenente la chiamata di funzione.

-u

Considera variabili e parametri non impostati diversi dai parametri speciali '@' o '*' come un errore quando si esegue l'espansione dei parametri. Verrà scritto un messaggio di errore nell'errore standard e uscirà una shell non interattiva.

Se non ti serve, sentiti libero di omettere la :+${array[@]}parte.

Nota anche che è essenziale utilizzare l' [[operatore qui, con [te ottieni:

$ 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

Se si desidera rilevare un array con elementi vuoti , comearr=("" "") vuoto, uguale aarr=()

Puoi incollare tutti gli elementi insieme e verificare se il risultato è di lunghezza zero. (Costruire una copia appiattita del contenuto dell'array non è l'ideale per le prestazioni se l'array potrebbe essere molto grande. Ma si spera che non si usi bash per programmi del genere ...)

Ma si "${arr[*]}"espande con elementi separati dal primo carattere di IFS. Quindi è necessario salvare / ripristinare IFS e farlo IFS=''per farlo funzionare, oppure verificare che la lunghezza della stringa == # di elementi dell'array - 1. (Un array di nelementi ha n-1separatori). Per far fronte a quello off-by-one, è più facile riempire la concatenazione di 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

test case 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

Purtroppo questo non riesce per arr=(): [[ 1 -ne 0 ]]. Quindi dovresti controllare prima gli array effettivamente vuoti separatamente.

O conIFS='' . Probabilmente vorresti salvare / ripristinare IFS invece di usare una subshell, perché non puoi ottenere facilmente un risultato da una subshell.

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

esempio:

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

non funziona con arr=()- è ancora solo una stringa vuota.

Nel mio caso, la seconda risposta non è stata sufficiente perché potrebbero esserci spazi bianchi. Sono venuto con:

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

Preferisco usare le doppie parentesi:

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

Doppie parentesi: https://stackoverflow.com/questions/669452/is-preferable-over-in-bash