W Bash, jaki jest najprostszy sposób sprawdzenia, czy tablica zawiera określoną wartość?

Edycja : Z pomocą odpowiedzi i komentarzy po kilku testach wymyśliłem:

function contains() {
    local n=$#
    local value=${!n}
    for ((i=1;i < $#;i++)) {
        if [ "${!i}" == "${value}" ]; then
            echo "y"
            return 0
        fi
    }
    echo "n"
    return 1
}

A=("one" "two" "three four")
if [ $(contains "${A[@]}" "one") == "y" ]; then
    echo "contains one"
fi
if [ $(contains "${A[@]}" "three") == "y" ]; then
    echo "contains three"
fi

Nie jestem pewien, czy to najlepsze rozwiązanie, ale wydaje się, że działa.

Zaletą tego podejścia jest to, że nie trzeba zapętlać wszystkich elementów (przynajmniej nie jawnie). Ale ponieważ array_to_string_internal()w array.c nadal zapętla elementy tablicy i łączy je w ciąg, prawdopodobnie nie jest to bardziej wydajne niż proponowane rozwiązania zapętlania, ale jest bardziej czytelne.

if [[ " ${array[@]} " =~ " ${value} " ]]; then
    # whatever you want to do when array contains value
fi

if [[ ! " ${array[@]} " =~ " ${value} " ]]; then
    # whatever you want to do when array doesn't contain value
fi

Zauważ, że w przypadkach, gdy szukana wartość jest jednym ze słów w elemencie tablicy ze spacjami, da fałszywe alarmy. Na przykład

array=("Jack Brown")
value="Jack"

Wyrażenie regularne zobaczy, że „Jack” znajduje się w tablicy, nawet jeśli nie jest. Musisz więc zmienić IFSi znaki separatora w wyrażeniu regularnym, jeśli nadal chcesz używać tego rozwiązania, takiego jak ten

IFS=$'\t'
array=("Jack Brown\tJack Smith")
unset IFS
value="Jack"

if [[ "\t${array[@]}\t" =~ "\t${value}\t" ]]; then
    echo "true"
else
    echo "false"
fi

Spowoduje to wydrukowanie „false”.

Oczywiście można to również wykorzystać jako oświadczenie testowe, pozwalając na wyrażenie go jako jednowierszowego

[[ " ${array[@]} " =~ " ${value} " ]] && echo "true" || echo "false"

Poniżej znajduje się mała funkcja do osiągnięcia tego. Wyszukiwany ciąg jest pierwszym argumentem, a reszta to elementy tablicy:

containsElement () {
  local e match="$1"
  shift
  for e; do [[ "$e" == "$match" ]] && return 0; done
  return 1
}

Uruchomienie testowe tej funkcji może wyglądać następująco:

$ array=("something to search for" "a string" "test2000")
$ containsElement "a string" "${array[@]}"
$ echo $?
0
$ containsElement "blaha" "${array[@]}"
$ echo $?
1

$ myarray=(one two three)
$ case "${myarray[@]}" in  *"two"*) echo "found" ;; esac
found

for i in "${array[@]}"
do
    if [ "$i" -eq "$yourValue" ] ; then
        echo "Found"
    fi
done

Dla ciągów:

for i in "${array[@]}"
do
    if [ "$i" == "$yourValue" ] ; then
        echo "Found"
    fi
done

Rozwiązanie jednowierszowe

printf '%s\n' ${myarray[@]} | grep -P '^mypattern$'

Wyjaśnienie

printfOświadczenie drukuje każdy element tablicy w osobnej linii.

grepOświadczenie używa znaków specjalnych ^i $znaleźć wiersz zawierający dokładnie wzór podany jako mypattern(nie więcej, nie mniej).

Stosowanie

Aby umieścić to w if ... thenoświadczeniu:

if printf '%s\n' ${myarray[@]} | grep -q -P '^mypattern$'; then
    # ...
fi

Dodałem -qflagę do grepwyrażenia, aby nie drukowało dopasowań; po prostu potraktuje istnienie dopasowania jako „prawdziwe”.

Jeśli potrzebujesz wydajności, nie chcesz za każdym razem przeszukiwać całej tablicy.

W takim przypadku możesz utworzyć tablicę asocjacyjną (tablicę skrótów lub słownik), która reprezentuje indeks tej tablicy. Oznacza to, że mapuje każdy element tablicy na swój indeks w tablicy:

make_index () {
  local index_name=$1
  shift
  local -a value_array=("$@")
  local i
  # -A means associative array, -g means create a global variable:
  declare -g -A ${index_name}
  for i in "${!value_array[@]}"; do
    eval ${index_name}["${value_array[$i]}"]=$i
  done
}

Następnie możesz użyć tego w następujący sposób:

myarray=('a a' 'b b' 'c c')
make_index myarray_index "${myarray[@]}"

I przetestuj członkostwo tak:

member="b b"
# the "|| echo NOT FOUND" below is needed if you're using "set -e"
test "${myarray_index[$member]}" && echo FOUND || echo NOT FOUND

Lub też:

if [ "${myarray_index[$member]}" ]; then 
  echo FOUND
fi

Zauważ, że to rozwiązanie działa poprawnie, nawet jeśli w testowanej wartości lub w wartościach tablic są spacje.

Jako bonus otrzymujesz również indeks wartości w tablicy z:

echo "<< ${myarray_index[$member]} >> is the index of $member"

Zwykle używam:

inarray=$(echo ${haystack[@]} | grep -o "needle" | wc -w)

wartość niezerowa oznacza, że ​​znaleziono dopasowanie.

Kolejna wkładka bez funkcji:

(for e in "${array[@]}"; do [[ "$e" == "searched_item" ]] && exit 0; done) && echo "found" || echo "not found"

Dzięki @Qwerty za informacje dotyczące spacji!

odpowiednia funkcja:

find_in_array() {
  local word=$1
  shift
  for e in "$@"; do [[ "$e" == "$word" ]] && return 0; done
  return 1
}

przykład:

some_words=( these are some words )
find_in_array word "${some_words[@]}" || echo "expected missing! since words != word"

containsElement () { for e in "${@:2}"; do [[ "$e" = "$1" ]] && return 0; done; return 1; }

Teraz poprawnie obsługuje puste tablice.

Oto niewielki wkład:

array=(word "two words" words)  
search_string="two"  
match=$(echo "${array[@]:0}" | grep -o $search_string)  
[[ ! -z $match ]] && echo "found !"  

Uwaga: w ten sposób nie rozróżnia się przypadku „dwa słowa”, ale nie jest to wymagane w pytaniu.

Jeśli chcesz zrobić szybki i brudny test, aby sprawdzić, czy warto iterować całą tablicę, aby uzyskać dokładne dopasowanie, Bash może traktować tablice jak skalary. Sprawdź dopasowanie w skalarach, jeśli nie, pomijanie pętli pozwala zaoszczędzić czas. Oczywiście możesz uzyskać fałszywe alarmy.

array=(word "two words" words)
if [[ ${array[@]} =~ words ]]
then
    echo "Checking"
    for element in "${array[@]}"
    do
        if [[ $element == "words" ]]
        then
            echo "Match"
        fi
    done
fi

Spowoduje to wyświetlenie „Sprawdzanie” i „Dopasuj”. Dzięki array=(word "two words" something)temu wyświetli się tylko „Sprawdzanie”. Dzięki array=(word "two widgets" something)nie będzie wyjścia.

To działa dla mnie:

# traditional system call return values-- used in an `if`, this will be true when returning 0. Very Odd.
contains () {
    # odd syntax here for passing array parameters: http://stackoverflow.com/questions/8082947/how-to-pass-an-array-to-a-bash-function
    local list=$1[@]
    local elem=$2

    # echo "list" ${!list}
    # echo "elem" $elem

    for i in "${!list}"
    do
        # echo "Checking to see if" "$i" "is the same as" "${elem}"
        if [ "$i" == "${elem}" ] ; then
            # echo "$i" "was the same as" "${elem}"
            return 0
        fi
    done

    # echo "Could not find element"
    return 1
}

Przykładowe wywołanie:

arr=("abc" "xyz" "123")
if contains arr "abcx"; then
    echo "Yes"
else
    echo "No"
fi

a=(b c d)

if printf '%s\0' "${a[@]}" | grep -Fqxz c
then
  echo 'array “a” contains value “c”'
fi

Jeśli wolisz, możesz użyć równoważnych długich opcji:

--fixed-strings --quiet --line-regexp --null-data

Pożyczanie od Dennis Williamson „s odpowiedzi , następujące rozwiązanie łączy tablic, muszli bezpieczny cytowanie i wyrażeń regularnych, aby uniknąć konieczności: iteracji po pętli; z zastosowaniem rur lub innych podprocesów; lub używając narzędzi innych niż bash.

declare -a array=('hello, stack' one 'two words' words last)
printf -v array_str -- ',,%q' "${array[@]}"

if [[ "${array_str},," =~ ,,words,, ]]
then
   echo 'Matches'
else
   echo "Doesn't match"
fi

Powyższy kod działa przy użyciu wyrażeń regularnych Bash w celu dopasowania do skróconej wersji zawartości tablicy. Istnieje sześć ważnych kroków, aby upewnić się, że dopasowanie wyrażenia regularnego nie może zostać oszukane przez sprytne kombinacje wartości w tablicy:

1. Skonstruować ciąg porównań przy użyciu wbudowanego Bash w printfskorupkach-cytowania %q. Cytowanie powłoki zapewni, że znaki specjalne staną się „bezpieczne dla powłoki” poprzez ucieczkę odwrotnym ukośnikiem \.
2. Wybierz znak specjalny, który będzie służył jako ogranicznik wartości. Separator MUSI być jednym ze znaków specjalnych, które zostaną użyte podczas ucieczki %q; to jedyny sposób, aby zagwarantować, że wartości w tablicy nie mogą być konstruowane w sprytny sposób, aby oszukać dopasowanie wyrażenia regularnego. Wybieram przecinek, ,ponieważ postać ta jest najbezpieczniejsza, gdy zostanie ewaluowana lub wykorzystana w nieoczekiwany sposób.
3. Połącz wszystkie elementy tablicy w jeden ciąg, używając dwóch wystąpień znaku specjalnego, aby służyć jako separator. Używając przecinka jako przykładu, użyłem ,,%qjako argumentu do printf. Jest to ważne, ponieważ dwa wystąpienia znaku specjalnego mogą pojawiać się obok siebie tylko wtedy, gdy występują jako separator; wszystkie inne przypadki postaci specjalnej zostaną usunięte.
4. Dołącz dwa końcowe wystąpienia separatora do ciągu, aby umożliwić dopasowanie do ostatniego elementu tablicy. Dlatego zamiast porównywać z ${array_str}, porównać z ${array_str},,.
5. Jeśli szukany ciąg docelowy jest dostarczany przez zmienną użytkownika, musisz uciec ze wszystkich wystąpień znaku specjalnego ukośnikiem odwrotnym. W przeciwnym razie dopasowanie wyrażenia regularnego staje się podatne na oszukanie przez sprytnie spreparowane elementy tablicy.
6. Wykonaj dopasowanie wyrażenia regularnego Bash względem łańcucha.

Mały dodatek do odpowiedzi @ ghostdog74 na temat używania caselogiki do sprawdzania, czy tablica zawiera określoną wartość:

myarray=(one two three)
word=two
case "${myarray[@]}" in  ("$word "*|*" $word "*|*" $word") echo "found" ;; esac

Lub z extglobwłączoną opcją, możesz to zrobić w następujący sposób:

myarray=(one two three)
word=two
shopt -s extglob
case "${myarray[@]}" in ?(*" ")"$word"?(" "*)) echo "found" ;; esac

Również możemy to zrobić if instrukcji:

myarray=(one two three)
word=two
if [[ $(printf "_[%s]_" "${myarray[@]}") =~ .*_\[$word\]_.* ]]; then echo "found"; fi

dany :

array=("something to search for" "a string" "test2000")
elem="a string"

następnie prosta kontrola:

if c=$'\x1E' && p="${c}${elem} ${c}" && [[ ! "${array[@]/#/${c}} ${c}" =~ $p ]]; then
  echo "$elem exists in array"
fi

gdzie

c is element separator
p is regex pattern

(Powodem przypisywania p oddzielnie zamiast używania wyrażenia bezpośrednio w [[]] jest utrzymanie kompatybilności z bash 4)

Łącząc kilka przedstawionych tutaj pomysłów, możesz stworzyć elegancki, jeśli zestawienie bez pętli, które pasuje dokładnie do słów .

$find="myword"
$array=(value1 value2 myword)
if [[ ! -z $(printf '%s\n' "${array[@]}" | grep -w $find) ]]; then
  echo "Array contains myword";
fi

To nie uruchomi się, wordlub valtylko dopasowania całego słowa. Zepsuje się, jeśli każda wartość tablicy zawiera wiele słów.

Generalnie piszę tego rodzaju narzędzia do działania na nazwie zmiennej, a nie na wartości zmiennej, przede wszystkim dlatego, że bash nie może przekazać zmiennych przez odwołanie.

Oto wersja, która działa z nazwą tablicy:

function array_contains # array value
{
    [[ -n "$1" && -n "$2" ]] || {
        echo "usage: array_contains <array> <value>"
        echo "Returns 0 if array contains value, 1 otherwise"
        return 2
    }

    eval 'local values=("${'$1'[@]}")'

    local element
    for element in "${values[@]}"; do
        [[ "$element" == "$2" ]] && return 0
    done
    return 1
}

W ten sposób przykład pytania staje się:

array_contains A "one" && echo "contains one"

itp.

Korzystanie grepiprintf

Sformatuj każdy element tablicy w nowej linii, a następnie grepw liniach.

if printf '%s\n' "${array[@]}" | grep -x -q "search string"; then echo true; else echo false; fi

$ array=("word", "two words")
$ if printf '%s\n' "${array[@]}" | grep -x -q "two words"; then echo true; else echo false; fi
true

Zauważ, że nie ma to problemów z delimetrami i spacjami.

Sprawdzanie jednowierszowe bez „grep” i pętli

if ( dlm=$'\x1F' ; IFS="$dlm" ; [[ "$dlm${array[*]}$dlm" == *"$dlm${item}$dlm"* ]] ) ; then
  echo "array contains '$item'"
else
  echo "array does not contain '$item'"
fi

Podejście to nie korzysta z zewnętrznych narzędzi, takich jak grepani pętle.

To, co się tutaj dzieje, to:

• używamy symboli zastępczych podciągów do znalezienia naszego elementu w tablicy połączonej w łańcuch;
• odcinamy możliwe fałszywe alarmy, umieszczając nasz element wyszukiwania między parą ograniczników;
• używamy znaku niedrukowalnego jako separatora, aby zachować bezpieczeństwo;
• osiągamy nasz ogranicznik używany również do konkatenacji macierzy przez tymczasowe zastąpienie IFS wartości zmiennej;
• zmienimy tę IFSwartość na tymczasową, oceniając nasze wyrażenie warunkowe w podpowłoce (w parze nawiasów)

Korzystanie z rozszerzania parametrów:

$ {parametr: + słowo} Jeśli parametr ma wartość zerową lub jest nieustawiony, nic nie jest podstawiane, w przeciwnym razie zastępowane jest rozwijanie słowa.

declare -A myarray
myarray[hello]="world"

for i in hello goodbye 123
do
  if [ ${myarray[$i]:+_} ]
  then
    echo ${!myarray[$i]} ${myarray[$i]} 
  else
    printf "there is no %s\n" $i
  fi
done

Po udzieleniu odpowiedzi przeczytałem inną odpowiedź, która szczególnie mi się podobała, ale była wadliwa i przegłosowana. Zainspirowałem się i oto dwa nowe podejścia, które według mnie są realne.

array=("word" "two words") # let's look for "two words"

za pomocą grepi printf:

(printf '%s\n' "${array[@]}" | grep -x -q "two words") && <run_your_if_found_command_here>

za pomocą for:

(for e in "${array[@]}"; do [[ "$e" == "two words" ]] && exit 0; done; exit 1) && <run_your_if_found_command_here>

Aby dodać wyniki not_found, dodaj || <run_your_if_notfound_command_here>

Oto moje zdanie na ten temat.

Wolałbym nie używać basha dla pętli, jeśli mogę tego uniknąć, ponieważ to wymaga czasu. Jeśli coś musi się zapętlić, niech to będzie coś napisanego w języku niższego poziomu niż skrypt powłoki.

function array_contains { # arrayname value
  local -A _arr=()
  local IFS=
  eval _arr=( $(eval printf '[%q]="1"\ ' "\${$1[@]}") )
  return $(( 1 - 0${_arr[$2]} ))
}

Działa to poprzez utworzenie tymczasowej tablicy asocjacyjnej, _arrktórej indeksy pochodzą z wartości tablicy wejściowej. (Zauważ, że tablice asocjacyjne są dostępne w wersji bash 4 i nowszych, więc ta funkcja nie będzie działać we wcześniejszych wersjach bash.) Ustawiliśmy, $IFSaby uniknąć podziału słów na białe znaki.

Funkcja nie zawiera wyraźnych pętli, chociaż wewnętrznie przebija się przez tablicę wejściową w celu zapełnienia printf. Format printf używa %qdo zapewnienia, że ​​dane wejściowe są ucieczkowe, dzięki czemu można je bezpiecznie wykorzystać jako klucze tablicy.

$ a=("one two" three four)
$ array_contains a three && echo BOOYA
BOOYA
$ array_contains a two && echo FAIL
$

Zauważ, że wszystko, czego używa ta funkcja, jest wbudowane w bash, więc nie ma żadnych zewnętrznych potoków ciągnących cię w dół, nawet w rozszerzeniu poleceń.

A jeśli nie lubisz używać eval... cóż, możesz zastosować inne podejście. :-)

Moja wersja techniki wyrażeń regularnych, która została już zasugerowana:

values=(foo bar)
requestedValue=bar

requestedValue=${requestedValue##[[:space:]]}
requestedValue=${requestedValue%%[[:space:]]}
[[ "${values[@]/#/X-}" =~ "X-${requestedValue}" ]] || echo "Unsupported value"

To, co się tutaj dzieje, polega na tym, że rozszerzasz całą tablicę obsługiwanych wartości na słowa i przygotowujesz określony ciąg, w tym przypadku „X-”, do każdej z nich, i robisz to samo z żądaną wartością. Jeśli ten rzeczywiście jest zawarty w tablicy, wynikowy ciąg znaków będzie co najwyżej pasował do jednego z powstałych tokenów lub wcale nie będzie odwrotnie. W tym ostatnim przypadku || operator uruchamia się i wiesz, że masz do czynienia z nieobsługiwaną wartością. Przed tym wszystkim żądana wartość jest usuwana ze wszystkich wiodących i końcowych białych znaków za pomocą standardowych operacji na łańcuchach powłoki.

Uważam, że jest czysty i elegancki, choć nie jestem zbyt pewny, jak skuteczny może być, jeśli Twój zestaw obsługiwanych wartości jest szczególnie duży.

Oto moje podejście do tego problemu. Oto krótka wersja:

function arrayContains() {
        local haystack=${!1}
        local needle="$2"
        printf "%s\n" ${haystack[@]} | grep -q "^$needle$"
}

I długa wersja, która moim zdaniem jest znacznie łatwiejsza dla oczu.

# With added utility function.
function arrayToLines() {
        local array=${!1}
        printf "%s\n" ${array[@]}
}

function arrayContains() {
        local haystack=${!1}
        local needle="$2"
        arrayToLines haystack[@] | grep -q "^$needle$"
}

Przykłady:

test_arr=("hello" "world")
arrayContains test_arr[@] hello; # True
arrayContains test_arr[@] world; # True
arrayContains test_arr[@] "hello world"; # False
arrayContains test_arr[@] "hell"; # False
arrayContains test_arr[@] ""; # False

Miałem przypadek, że musiałem sprawdzić, czy identyfikator znajduje się na liście identyfikatorów wygenerowanych przez inny skrypt / polecenie. Dla mnie zadziałało:

# the ID I was looking for
ID=1

# somehow generated list of IDs
LIST=$( <some script that generates lines with IDs> )
# list is curiously concatenated with a single space character
LIST=" $LIST "

# grep for exact match, boundaries are marked as space
# would therefore not reliably work for values containing a space
# return the count with "-c"
ISIN=$(echo $LIST | grep -F " $ID " -c)

# do your check (e. g. 0 for nothing found, everything greater than 0 means found)
if [ ISIN -eq 0 ]; then
    echo "not found"
fi
# etc.

Możesz także skrócić / skompresować w następujący sposób:

if [ $(echo " $( <script call> ) " | grep -F " $ID " -c) -eq 0 ]; then
    echo "not found"
fi

W moim przypadku uruchomiłem jq, aby przefiltrować JSON pod kątem listy identyfikatorów i musiałem później sprawdzić, czy mój identyfikator znajduje się na tej liście i to działało najlepiej dla mnie. Nie będzie działać w przypadku ręcznie tworzonych tablic typu, LIST=("1" "2" "4")ale w przypadku danych wyjściowych skryptu oddzielonych znakiem nowej linii.

PS .: nie mogę skomentować odpowiedzi, ponieważ jestem stosunkowo nowy ...

Poniższy kod sprawdza, czy dana wartość znajduje się w tablicy i zwraca jej zerowe przesunięcie:

A=("one" "two" "three four")
VALUE="two"

if [[ "$(declare -p A)" =~ '['([0-9]+)']="'$VALUE'"' ]];then
  echo "Found $VALUE at offset ${BASH_REMATCH[1]}"
else
  echo "Couldn't find $VALUE"
fi

Dopasowanie jest wykonywane dla pełnych wartości, dlatego ustawienie WARTOŚĆ = „trzy” nie będzie pasować.

Warto to zbadać, jeśli nie chcesz iterować:

#!/bin/bash
myarray=("one" "two" "three");
wanted="two"
if `echo ${myarray[@]/"$wanted"/"WAS_FOUND"} | grep -q "WAS_FOUND" ` ; then
 echo "Value was found"
fi
exit

Fragment dostosowany z: http://www.thegeekstuff.com/2010/06/bash-array-tutorial/ Myślę, że jest całkiem sprytny.

EDYCJA: Prawdopodobnie możesz po prostu zrobić:

if `echo ${myarray[@]} | grep -q "$wanted"` ; then
echo "Value was found"
fi

Ale to ostatnie działa tylko wtedy, gdy tablica zawiera unikalne wartości. Szukanie 1 w „143” da fałszywie dodatni, metinks.

Trochę późno, ale możesz użyć tego:

#!/bin/bash
# isPicture.sh

FILE=$1
FNAME=$(basename "$FILE") # Filename, without directory
EXT="${FNAME##*.}" # Extension

FORMATS=(jpeg JPEG jpg JPG png PNG gif GIF svg SVG tiff TIFF)

NOEXT=( ${FORMATS[@]/$EXT} ) # Formats without the extension of the input file

# If it is a valid extension, then it should be removed from ${NOEXT},
#+making the lengths inequal.
if ! [ ${#NOEXT[@]} != ${#FORMATS[@]} ]; then
    echo "The extension '"$EXT"' is not a valid image extension."
    exit
fi

Wymyśliłem ten, który okazuje się działać tylko w Zsh, ale myślę, że ogólne podejście jest dobre.

arr=( "hello world" "find me" "what?" )
if [[ "${arr[@]/#%find me/}" != "${arr[@]}" ]]; then
    echo "found!"
else
    echo "not found!"
fi

Wyciągasz wzór z każdego elementu tylko wtedy, gdy zaczyna się ${arr[@]/#pattern/}lub kończy ${arr[@]/%pattern/}. Te dwie substytucje działają w trybie bash, ale oba jednocześnie${arr[@]/#%pattern/} działają tylko w Zsh.

Jeśli zmodyfikowana tablica jest równa oryginałowi, to nie zawiera elementu.

Edytować:

Ten działa w bash:

 function contains () {
        local arr=(${@:2})
        local el=$1
        local marr=(${arr[@]/#$el/})
        [[ "${#arr[@]}" != "${#marr[@]}" ]]
    }

Po podstawieniu porównuje długość obu tablic. Oczywiście, jeśli tablica zawiera element, podstawienie całkowicie go usunie, a liczba będzie się różnić.