Überprüfen Sie, ob das Array in Bash leer ist

Ich habe ein Array, das mit verschiedenen Fehlermeldungen gefüllt wird, während mein Skript ausgeführt wird.

Ich brauche eine Möglichkeit, um zu überprüfen, ob es am Ende des Skripts leer ist, und eine bestimmte Aktion auszuführen, wenn dies der Fall ist.

Ich habe bereits versucht, es wie eine normale VAR zu behandeln und es mit -z zu überprüfen, aber das scheint nicht zu funktionieren. Gibt es eine Möglichkeit zu überprüfen, ob ein Array in Bash leer ist oder nicht?

Angenommen, Ihr Array ist $errors, überprüfen Sie einfach, ob die Anzahl der Elemente Null ist.

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

In diesem Fall verwende ich in der Regel die arithmetische Erweiterung:

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

Sie können das Array auch als einfache Variable betrachten. Auf diese Weise nur mit

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

oder mit der anderen Seite

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

Das Problem bei dieser Lösung besteht darin , dass , wenn ein Array wie folgt erklärt: array=('' foo). Bei diesen Überprüfungen wird das Array als leer gemeldet, während dies eindeutig nicht der Fall ist. (danke @musiphil!)

Verwenden [ -z "$array[@]" ]ist natürlich auch keine Lösung. Wenn geschweifte Klammern nicht angegeben werden, wird versucht, sie $arrayals Zeichenfolge zu interpretieren ( [@]ist in diesem Fall eine einfache Literalzeichenfolge) und wird daher immer als falsch gemeldet: "Ist die Literalzeichenfolge [@]leer?" Ganz sicher nicht.

Ich habe es überprüft mit 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

und 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

Im letzteren Fall benötigen Sie folgendes Konstrukt:

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

Damit es bei leeren oder nicht gesetzten Arrays nicht fehlschlägt. Das ist, wenn Sie tun, set -euwie ich es normalerweise tue. Dies sorgt für eine strengere Fehlerprüfung. Aus den Dokumenten :

-e

Beenden Sie sofort, wenn eine Pipeline (siehe Pipelines), die aus einem einzelnen einfachen Befehl (siehe Einfache Befehle), einer Liste (siehe Listen) oder einem zusammengesetzten Befehl (siehe Zusammengesetzte Befehle) bestehen kann, einen Status ungleich Null zurückgibt. Die Shell wird nicht beendet, wenn der fehlgeschlagene Befehl Teil der Befehlsliste ist, die unmittelbar auf ein while- oder until-Schlüsselwort folgt, Teil des Tests in einer if-Anweisung ist, Teil eines Befehls, der in einem && oder || ausgeführt wird liste mit Ausnahme des Befehls, der auf das letzte && oder || folgt, jeden Befehl in einer Pipeline außer dem letzten, oder wenn der Rückgabestatus des Befehls mit! invertiert wird. Wenn ein zusammengesetzter Befehl außer einer Subshell einen Status ungleich Null zurückgibt, weil ein Befehl fehlgeschlagen ist, während -e ignoriert wurde, wird die Shell nicht beendet. Ein Trap auf ERR, falls gesetzt, wird ausgeführt, bevor die Shell beendet wird.

Diese Option gilt für die Shell-Umgebung und jede Subshell-Umgebung separat (siehe Command Execution Environment) und kann dazu führen, dass Subshells beendet werden, bevor alle Befehle in der Subshell ausgeführt werden.

Wenn ein zusammengesetzter Befehl oder eine Shell-Funktion in einem Kontext ausgeführt wird, in dem -e ignoriert wird, ist keiner der Befehle, die innerhalb des zusammengesetzten Befehls oder Funktionskörpers ausgeführt werden, von der Einstellung -e betroffen, selbst wenn -e festgelegt ist und ein Befehl a zurückgibt Fehlerstatus. Wenn ein zusammengesetzter Befehl oder eine Shell-Funktion -e setzt, während sie in einem Kontext ausgeführt wird, in dem -e ignoriert wird, hat diese Einstellung keine Auswirkung, bis der zusammengesetzte Befehl oder der Befehl, der den Funktionsaufruf enthält, abgeschlossen ist.

-u

Behandeln Sie nicht festgelegte Variablen und Parameter außer den Sonderparametern '@' oder '*' als Fehler, wenn Sie eine Parametererweiterung durchführen. Eine Fehlermeldung wird in den Standardfehler geschrieben und eine nicht interaktive Shell wird beendet.

Wenn Sie das nicht benötigen, können Sie einen :+${array[@]}Teil weglassen .

Auch merken Sie , dass es wichtig ist , zu verwenden [[Operator hier, mit [Ihnen zu bekommen:

$ 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

Wenn Sie ein Array mit leeren Elementen erkennen möchten , z. B.arr=("" "") so leer wiearr=()

Sie können alle Elemente zusammenfügen und prüfen, ob das Ergebnis eine Länge von Null hat. (Das Erstellen einer reduzierten Kopie des Array-Inhalts ist für die Leistung nicht ideal, wenn das Array sehr groß sein könnte. Hoffentlich verwenden Sie bash nicht für solche Programme ...)

Erweitert "${arr[*]}"sich jedoch mit Elementen, die durch das erste Zeichen von IFS. Sie müssen also IFS speichern / wiederherstellen und dafür IFS=''sorgen, dass dies funktioniert, oder Sie müssen überprüfen, ob die Zeichenfolgenlänge == # der Array-Elemente - 1 ist. (Ein Array von nElementen verfügt über n-1Trennzeichen.) Um dieses Problem zu lösen, ist es am einfachsten, die Verkettung mit 1 aufzufüllen

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

Testfall mit 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

Leider ist diese nicht für arr=(): [[ 1 -ne 0 ]]. Sie müssen also zuerst separat nach tatsächlich leeren Arrays suchen.

Oder mitIFS='' . Wahrscheinlich möchten Sie IFS speichern / wiederherstellen, anstatt eine Subshell zu verwenden, da Sie mit einer Subshell nicht einfach ein Ergebnis erzielen können.

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

Beispiel:

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

funktioniert mit arr=()- es ist immer noch nur die leere Zeichenfolge.

In meinem Fall war die zweite Antwort nicht genug, weil es Leerzeichen geben könnte. Ich kam mit:

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

Ich bevorzuge doppelte Klammern:

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

Doppelte Klammern: https://stackoverflow.com/questions/669452/is-preferable-over-in-bash