Vérifier si le tableau est vide dans Bash

J'ai un tableau qui est rempli avec différents messages d'erreur pendant l'exécution de mon script.

J'ai besoin d'un moyen de vérifier si c'est vide ou non à la fin du script et de prendre une action spécifique si c'est le cas.

J'ai déjà essayé de le traiter comme un revendeur à valeur normale et d'utiliser -z pour le vérifier, mais cela ne semble pas fonctionner. Existe-t-il un moyen de vérifier si un tableau est vide ou non dans Bash?

En supposant que votre tableau soit $errors, vérifiez simplement si le nombre d'éléments est égal à zéro.

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

J'utilise généralement l'expansion arithmétique dans ce cas:

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

Vous pouvez également considérer le tableau comme une simple variable. De cette façon, juste en utilisant

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

ou en utilisant l'autre côté

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

Le problème avec cette solution est que si un tableau est déclaré comme ceci: array=('' foo). Ces vérifications indiqueront que le tableau est vide, alors que ce n'est clairement pas le cas. (merci @musiphil!)

L'utilisation [ -z "$array[@]" ]n'est clairement pas une solution non plus. Ne pas spécifier les accolades essaie d'interpréter $arraycomme une chaîne (il [@]s'agit dans ce cas d'une chaîne littérale simple) et est donc toujours signalé comme étant faux: "la chaîne littérale est-elle [@]vide?" Clairement pas.

J'ai vérifié avec 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

et 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

Dans ce dernier cas, vous avez besoin de la construction suivante:

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

pour qu'il n'échoue pas sur un tableau vide ou non défini. C'est si tu fais set -eucomme je le fais d'habitude. Cela permet une vérification d'erreur plus stricte. De la docs :

-e

Quittez immédiatement si un pipeline (voir Pipelines), qui peut consister en une seule commande (voir Commandes simples), une liste (voir Listes) ou une commande composée (voir Commandes composées) renvoie un statut différent de zéro. Le shell ne se ferme pas si la commande qui échoue fait partie de la liste de commandes suivant immédiatement un mot-clé while ou Until, une partie du test dans une instruction if, une partie d'une commande exécutée dans un && ou || liste sauf la commande suivant le && ou || final, toutes les commandes d'un pipeline sauf le dernier, ou si l'état de retour de la commande est inversé avec!. Si une commande composée autre qu'un sous-shell renvoie un statut différent de zéro car une commande a échoué alors que l'option -e était ignorée, le shell ne se ferme pas. Une interruption sur ERR, si définie, est exécutée avant la sortie du shell.

Cette option s'applique à l'environnement shell et à chaque environnement de sous-shell séparément (voir Environnement d'exécution des commandes), et peut entraîner la fermeture des sous-shell avant l'exécution de toutes les commandes du sous-shell.

Si une commande composée ou une fonction shell s'exécute dans un contexte où -e est ignoré, aucune des commandes exécutées dans la commande composée ou le corps de la fonction n'est affectée par le paramètre -e, même si -e est défini et qu'une commande renvoie un état d'échec. Si une commande composée ou une fonction shell définit -e lors de l'exécution dans un contexte où -e est ignoré, ce paramètre n'aura aucun effet tant que la commande composée ou la commande contenant l'appel de fonction ne sera pas terminée.

-u

Traitez les variables non définies et les paramètres autres que les paramètres spéciaux «@» ou «*» comme une erreur lors de l’expansion des paramètres. Un message d'erreur sera écrit sur l'erreur standard et un shell non interactif se fermera.

Si vous n'en avez pas besoin, n'hésitez pas à en omettre une :+${array[@]}partie.

Notez également qu'il est essentiel d'utiliser [[operator ici, avec [vous obtenez:

$ 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 vous voulez détecter un tableau avec des éléments vides , commearr=("" "") vide, identique àarr=()

Vous pouvez coller tous les éléments ensemble et vérifier si le résultat est zéro. (Construire une copie aplatie du contenu du tableau n'est pas idéal pour la performance si le tableau peut être très grand. Mais j'espère que vous n'utilisez pas bash pour de tels programmes ...)

Mais se "${arr[*]}"développe avec des éléments séparés par le premier caractère de IFS. Donc, vous devez enregistrer / restaurer IFS et le faire IFS=''pour que cela fonctionne, ou bien vérifiez que la longueur de la chaîne == # d'éléments de tableau - 1. (Un tableau d' néléments a des n-1séparateurs). Pour régler ce problème, il est plus facile d’enrichir la concaténation de 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

cas de test avec 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

Malheureusement , cela ne fonctionne pas pour arr=(): [[ 1 -ne 0 ]]. Il est donc nécessaire de vérifier séparément les tableaux réellement vides.

Ou avecIFS='' . Vous voudrez probablement sauvegarder / restaurer IFS au lieu d'utiliser un sous-shell, car vous ne pouvez pas obtenir facilement le résultat d'un sous-shell.

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

exemple:

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

ne fonctionne avec arr=()- il est encore juste la chaîne vide.

Dans mon cas, la deuxième réponse ne suffisait pas, car il pouvait y avoir des espaces. Je suis venu avec:

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

Je préfère utiliser les doubles crochets:

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

Double crochets: https://stackoverflow.com/questions/669452/is-preferable-over-in-bash