Der einfachste Weg, nach einem Index oder einem Schlüssel in einem Array zu suchen?

Mit:

set -o nounset

1) Mit einem indizierten array wie:

myArray=( "red" "black" "blue" )

Welches ist der kürzeste Weg, um zu überprüfen, wenn das element auf 1 gesetzt ist?
Manchmal benutze ich die folgenden:

test "${#myArray[@]}" -gt "1" && echo "1 exists" || echo "1 doesn't exist"

Ich würde gerne wissen, ob es eine bevorzugte.

2) Umgang mit nicht-konsekutive Indizes?

myArray=()
myArray[12]="red"
myArray[51]="black"
myArray[129]="blue"

Wie quick check, der '51' ist schon gesetzt, zum Beispiel?

3) Umgang mit assoziativen arrays?

declare -A myArray
myArray["key1"]="red"
myArray["key2"]="black"
myArray["key3"]="blue"

Wie quick check, 'key2' wird bereits verwendet, zum Beispiel?

Dank

BEARBEITET
Der einfachste Weg scheint mir:

if test "${myArray['key_or_index']+isset}"
    then
        echo "yes"
    else
        echo "no"
fi;

Dies funktioniert sowohl für indizierte und assoziative arrays. Keine Fehler angezeigt, die mit " set -o nounset.
Dank doubleDown für das headup.

InformationsquelleAutor der Frage Luca Borrione | 2012-11-04

86

Um zu überprüfen, ob das element gesetzt ist (gilt sowohl für indizierte und assoziative Arrays)
```
[ ${array[key]+abc} ] && echo "exists"
```
Im Grunde, was ${array[key]+abc} tut, ist
- wenn array[key] festgelegt ist, zurück abc
- wenn array[key] ist nicht festgelegt, nichts zurück
Referenzen:
1. Sehen Parameter Expansion im Bash-manual und die kleine Notiz
  
  wenn der Doppelpunkt weggelassen wird, wird die operator-tests nur auf die Existenz [von parameter]
2. Diese Antwort ist eigentlich angepasst, aus der die Antworten für diese Frage ALSO: Wie Sie feststellen, ob ein string definiert ist, nicht in einer bash-shell-Skript?
Wrapper-Funktion:
```
exists(){
  if [ "$2" != in ]; then
    echo "Incorrect usage."
    echo "Correct usage: exists {key} in {array}"
    return
  fi   
  eval '[ ${'$3'[$1]+muahaha} ]'  
}
```
Beispielsweise
```
if ! exists key in array; then echo "No such array element"; fi 
```
InformationsquelleAutor der Antwort doubleDown

Leider, bash geben, keine Möglichkeit, den Unterschied betwen leer und undefined variable.

Aber es gibt einige Möglichkeiten:

$ array=()
$ array[12]="red"
$ array[51]="black"
$ array[129]="blue"

$ echo ${array[@]}
red black blue

$ echo ${!array[@]}
12 51 129

$ echo "${#array[@]}"
3

$ printf "%s\n" ${!array[@]}|grep -q ^51$ && echo 51 exist
51 exist

$ printf "%s\n" ${!array[@]}|grep -q ^52$ && echo 52 exist

(geben keine Antwort)

Und für assoziatives array, du könntest das gleiche:

$ unset array
$ declare -A array
$ array["key1"]="red"
$ array["key2"]="black"
$ array["key3"]="blue"
$ echo ${array[@]}
blue black red

$ echo ${!array[@]}
key3 key2 key1

$ echo ${#array[@]}
3

$ set | grep ^array=
array=([key3]="blue" [key2]="black" [key1]="red" )

$ printf "%s\n" ${!array[@]}|grep -q ^key2$ && echo key2 exist || echo key2 not exist
key2 exist

$ printf "%s\n" ${!array[@]}|grep -q ^key5$ && echo key5 exist || echo key5 not exist
key5 not exist

Könnten Sie den job tun, ohne die Notwendigkeit von externen tools (kein printf|grep als reinen bash), und warum nicht, bauen checkIfExist() als eine neue bash-Funktion:

$ checkIfExist() {
    eval 'local keys=${!'$1'[@]}';
    eval "case '$2' in
        ${keys///|}) return 0 ;;
        * ) return 1 ;;
      esac";
}

$ checkIfExist array key2 && echo exist || echo don\'t
exist

$ checkIfExist array key5 && echo exist || echo don\'t
don't

oder sogar eine neue erstellen getIfExist bash-Funktion, die den gewünschten Wert ein und beenden Sie mit dem falschen Ergebnis-code, wenn gewünschte Wert nicht vorhanden:

$ getIfExist() {
    eval 'local keys=${!'$1'[@]}';
    eval "case '$2' in
        ${keys///|}) echo \${$1[$2]};return 0 ;;
        * ) return 1 ;;
      esac";
}

$ getIfExist array key1
red
$ echo $?
0

$ # now with an empty defined value
$ array["key4"]=""
$ getIfExist array key4

$ echo $?
0
$ getIfExist array key5
$ echo $?
1

InformationsquelleAutor der Antwort F. Hauri

getestet bash 4.3.39(1)-release

declare -A fmap
fmap['foo']="boo"

key='foo'
# should echo foo is set to 'boo'
if [[ -z "${fmap[${key}]}" ]]; then echo "$key is unset in fmap"; else echo "${key} is set to '${fmap[${key}]}'"; fi
key='blah'
# should echo blah is unset in fmap
if [[ -z "${fmap[${key}]}" ]]; then echo "$key is unset in fmap"; else echo "${key} is set to '${fmap[${key}]}'"; fi

InformationsquelleAutor der Antwort gdoubleod

Aus man bash, bedingte Ausdrücke:

-v varname
              True if the shell variable varname is set (has been assigned a value).

Beispiel:

declare -A foo
foo[bar]="this is bar"
foo[baz]=""
if [[ -v "foo[bar]" ]] ; then
  echo "foo[bar] is set"
fi
if [[ -v "foo[baz]" ]] ; then
  echo "foo[baz] is set"
fi
if [[ -v "foo[quux]" ]] ; then
  echo "foo[quux] is set"
fi

Diese zeigen, dass beide foo[bar] und foo[baz] gesetzt sind (auch wenn letzteres eingestellt ist, auf einen leeren Wert) und foo[quux] nicht.

InformationsquelleAutor der Antwort Vineet

Schrieb ich eine Funktion, um zu überprüfen, ob ein Schlüssel in einem array existiert in der Bash:

# Check if array key exists
# Usage: array_key_exists $array_name $key
# Returns: 0 = key exists, 1 = key does NOT exist
function array_key_exists() {
    local _array_name="$1"
    local _key="$2"
    local _cmd='echo ${!'$_array_name'[@]}'
    local _array_keys=($(eval $_cmd))
    local _key_exists=$(echo " ${_array_keys[@]} " | grep " $_key " &>/dev/null; echo $?)
    [[ "$_key_exists" = "0" ]] && return 0 || return 1
}

Beispiel

declare -A my_array
my_array['foo']="bar"

if [[ "$(array_key_exists 'my_array' 'foo'; echo $?)" = "0" ]]; then
    echo "OK"
else
    echo "ERROR"
fi

Getestet mit GNU bash, version 4.1.5(1)-release (i486-pc-linux-gnu)

InformationsquelleAutor der Antwort Lucas Stad

Dies ist der einfachste Weg, fand ich für die Skripte.

<search> ist die Zeichenfolge, die Sie wollen, zu finden, ASSOC_ARRAY die Namen der Variablen halten Sie Ihr assoziatives array.

Dependign auf, was Sie erreichen wollen:

Schlüssel vorhanden ist:

if grep -qe "<search>" <(echo "${!ASSOC_ARRAY[@]}"); then echo key is present; fi

- Schlüssel existiert nicht:

if ! grep -qe "<search>" <(echo "${!ASSOC_ARRAY[@]}"); then echo key not present; fi

Wert vorhanden ist:

if grep -qe "<search>" <(echo "${ASSOC_ARRAY[@]}"); then echo value is present; fi

Wert existiert nicht:

if ! grep -qe "<search>" <(echo "${ASSOC_ARRAY[@]}"); then echo value not present; fi

InformationsquelleAutor der Antwort sjas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.