No Bash, qual é a maneira mais simples de testar se uma matriz contém um determinado valor?

Edit : Com a ajuda das respostas e dos comentários, após alguns testes, vim com isso:

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

Não tenho certeza se é a melhor solução, mas parece funcionar.

Essa abordagem tem a vantagem de não precisar fazer um loop sobre todos os elementos (pelo menos não explicitamente). Mas como array_to_string_internal()no array.c ainda faz um loop sobre os elementos do array e os concatena em uma string, provavelmente não é mais eficiente do que as soluções de loop propostas, mas é mais legível.

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

Observe que nos casos em que o valor que você está procurando é uma das palavras em um elemento da matriz com espaços, ele fornecerá falsos positivos. Por exemplo

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

O regex verá "Jack" como estando na matriz, mesmo que não esteja. Portanto, você precisará alterar IFSos caracteres separadores em sua regex, se ainda quiser usar esta solução, como esta

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

Isso imprimirá "false".

Obviamente, isso também pode ser usado como uma declaração de teste, permitindo que seja expresso como uma linha

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

Abaixo está uma pequena função para conseguir isso. A cadeia de pesquisa é o primeiro argumento e o restante são os elementos da matriz:

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

Uma execução de teste dessa função pode se parecer com:

$ 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

Para strings:

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

Solução de uma linha

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

Explicação

A printfinstrução imprime cada elemento da matriz em uma linha separada.

A grepdeclaração usa os caracteres especiais ^e $encontra uma linha que contém exatamente o padrão fornecido como mypattern(nem mais, nem menos).

Uso

Para colocar isso em uma if ... thendeclaração:

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

Eu adicionei um -qsinalizador à grepexpressão para que ela não imprima correspondências; tratará apenas a existência de uma correspondência como "verdadeira".

Se você precisar de desempenho, não deseja percorrer toda a matriz toda vez que pesquisar.

Nesse caso, você pode criar uma matriz associativa (tabela de hash ou dicionário) que represente um índice dessa matriz. Ou seja, ele mapeia cada elemento da matriz em seu índice na matriz:

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
}

Então você pode usá-lo assim:

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

E teste a associação da seguinte forma:

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

Ou também:

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

Observe que esta solução faz a coisa certa, mesmo que haja espaços no valor testado ou nos valores da matriz.

Como bônus, você também obtém o índice do valor dentro da matriz com:

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

Eu normalmente apenas uso:

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

um valor diferente de zero indica que uma correspondência foi encontrada.

Outro liner sem função:

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

Obrigado @ Qwerty pelo aviso sobre os espaços!

função correspondente:

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

exemplo:

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; }

Agora lida com matrizes vazias corretamente.

Aqui está uma pequena contribuição:

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

Nota: dessa maneira não distingue o caso "duas palavras", mas isso não é necessário na pergunta.

Se você deseja fazer um teste rápido e sujo para ver se vale a pena repetir toda a matriz para obter uma correspondência precisa, o Bash pode tratar matrizes como escalares. Teste para uma correspondência no escalar, se nenhum, pular o loop economiza tempo. Obviamente, você pode obter falsos positivos.

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

Isso exibirá "Checking" e "Match". Com array=(word "two words" something)ele, somente será emitida "Verificação". Com array=(word "two widgets" something)não haverá saída.

Isso está funcionando para mim:

# 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
}

Chamada de exemplo:

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

Se preferir, você pode usar opções longas equivalentes:

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

Tomando emprestado a resposta de Dennis Williamson , a solução a seguir combina matrizes, citações seguras de shell e expressões regulares para evitar a necessidade de: iterar sobre loops; usando tubos ou outros subprocessos; ou usando utilitários que não sejam do 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

O código acima funciona usando expressões regulares do Bash para corresponder a uma versão rigorosa do conteúdo da matriz. Há seis etapas importantes para garantir que a correspondência da expressão regular não possa ser enganada por combinações inteligentes de valores na matriz:

1. Construa a string de comparação usando a printfcitação de shell incorporada do Bash %q,. A citação de shell garantirá que caracteres especiais se tornem "seguros para shell" ao serem escapados com barra invertida\ .
2. Escolha um caractere especial para servir como um delimitador de valor. O delimitador TEM QUE ser um dos caracteres especiais que serão escapados ao usar %q; essa é a única maneira de garantir que os valores dentro da matriz não possam ser construídos de maneiras inteligentes para enganar a correspondência de expressão regular. Eu escolho vírgula, porque esse personagem é o mais seguro quando avaliado ou usado de maneira inesperada.
3. Combine todos os elementos da matriz em uma única sequência, usando duas instâncias do caractere especial para servir como delimitador. Usando vírgula como exemplo, usei ,,%qcomo argumento para printf. Isso é importante porque duas instâncias do caractere especial só podem aparecer próximas uma da outra quando aparecem como delimitador; todas as outras instâncias do caractere especial serão escapadas.
4. Anexe duas instâncias à direita do delimitador à string, para permitir correspondências contra o último elemento da matriz. Assim, em vez de comparar contra ${array_str}, compare contra ${array_str},,.
5. Se a sequência de destino que você estiver procurando for fornecida por uma variável do usuário, você deverá escapar de todas as instâncias do caractere especial com uma barra invertida. Caso contrário, a correspondência de expressão regular fica vulnerável a ser enganada por elementos de matriz criados de maneira inteligente.
6. Execute uma correspondência de expressão regular do Bash na string.

Uma pequena adição à resposta de @ ghostdog74 sobre o uso da caselógica para verificar se a matriz contém um valor específico:

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

Ou com a extglobopção ativada, você pode fazer o seguinte:

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

Também podemos fazê-lo com a ifdeclaração:

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

dado:

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

depois, uma simples verificação de:

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

Onde

c is element separator
p is regex pattern

(O motivo para atribuir p separadamente, em vez de usar a expressão diretamente dentro de [[]] é manter a compatibilidade com o bash 4)

Combinando algumas das idéias apresentadas aqui, você pode criar uma declaração elegante, sem loops, que corresponda exatamente às palavras .

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

Isso não será acionado wordou val, apenas correspondências de palavras inteiras. Ele será interrompido se cada valor da matriz contiver várias palavras.

Geralmente, escrevo esse tipo de utilitário para operar com o nome da variável, e não com o valor da variável, principalmente porque o bash não pode passar variáveis ​​por referência.

Aqui está uma versão que funciona com o nome da matriz:

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
}

Com isso, o exemplo da pergunta se torna:

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

etc.

Usando grepeprintf

Formate cada membro da matriz em uma nova linha, depois grepas linhas.

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

Observe que isso não tem problemas com delimitadores e espaços.

Verificação em uma linha sem 'grep' e loops

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

Essa abordagem não usa utilitários externos como grepnem loops.

O que acontece aqui é:

• usamos um combinador de substring curinga para encontrar nosso item na matriz concatenada em uma string;
• eliminamos possíveis falsos positivos colocando nosso item de pesquisa entre um par de delimitadores;
• usamos um caractere não imprimível como delimitador, para estar do lado seguro;
• alcançamos que nosso delimitador também seja usado para concatenação de matriz pela substituição temporária do IFSvalor da variável;
• tornamos essa IFSsubstituição de valor temporária avaliando nossa expressão condicional em uma subcasca (dentro de um par de parênteses)

Usando expansão de parâmetro:

$ {parameter: + word} Se o parâmetro for nulo ou não definido, nada será substituído; caso contrário, a expansão da palavra será substituída.

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

Depois de ter respondido, li outra resposta que particularmente gostei, mas que foi falho e prejudicada. Eu me inspirei e aqui estão duas novas abordagens que considero viáveis.

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

usando grepeprintf :

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

usando for:

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

Para resultados not_found, adicione || <run_your_if_notfound_command_here>

Aqui está a minha opinião sobre isso.

Prefiro não usar o loop for do bash se puder evitá-lo, pois isso leva tempo para ser executado. Se algo tiver que ser repetido, seja algo que foi escrito em uma linguagem de nível inferior ao script de shell.

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

Isso funciona criando uma matriz associativa temporária _arr, cujos índices são derivados dos valores da matriz de entrada. (Observe que matrizes associativas estão disponíveis no bash 4 e acima, portanto, essa função não funcionará nas versões anteriores do bash.) Definimos $IFSpara evitar a divisão de palavras no espaço em branco.

A função não contém loops explícitos, embora as etapas internas do bash na matriz de entrada sejam preenchidas printf. O formato printf é usado %qpara garantir que os dados de entrada sejam escapados, de forma que possam ser usados ​​com segurança como chaves de matriz.

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

Observe que tudo o que essa função usa é incorporado ao bash, portanto, não há canais externos arrastando você para baixo, mesmo na expansão de comando.

E se você não gosta de usar eval... bem, você é livre para usar outra abordagem. :-)

Minha versão da técnica de expressões regulares já foi sugerida:

values=(foo bar)
requestedValue=bar

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

O que está acontecendo aqui é que você está expandindo toda a matriz de valores suportados em palavras e anexando uma sequência específica, "X-", neste caso, a cada um deles, e fazendo o mesmo com o valor solicitado. Se este realmente estiver contido na matriz, a sequência resultante corresponderá, no máximo, a um dos tokens resultantes, ou nenhum ao contrário. Neste último caso, o || O operador é acionado e você sabe que está lidando com um valor não suportado. Antes disso, o valor solicitado é retirado de todos os espaços em branco iniciais e finais através da manipulação padrão de strings de shell.

É limpo e elegante, acredito, embora não tenha muita certeza do desempenho, se sua matriz de valores suportados for particularmente grande.

Aqui está a minha opinião sobre este problema. Aqui está a versão curta:

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

E a versão longa, que eu acho que é muito mais fácil para os olhos.

# 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$"
}

Exemplos:

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

Tive o caso de verificar se havia um ID em uma lista de IDs gerados por outro script / comando. Para mim trabalhou o seguinte:

# 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.

Você também pode encurtar / compactar assim:

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

No meu caso, eu estava executando o jq para filtrar algum JSON para obter uma lista de IDs e tive que verificar mais tarde se meu ID estava nessa lista e isso funcionou melhor para mim. Não funcionará para matrizes criadas manualmente do tipoLIST=("1" "2" "4") mas para com saída de script separada por nova linha.

PS .: não pude comentar uma resposta porque sou relativamente nova ...

O código a seguir verifica se um determinado valor está na matriz e retorna seu deslocamento com base em zero:

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

A correspondência é feita com os valores completos, portanto, definir VALUE = "três" não corresponderia.

Vale a pena investigar se você não quiser repetir:

#!/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

Snippet adaptado de: http://www.thegeekstuff.com/2010/06/bash-array-tutorial/ Eu acho que é bem inteligente.

Edição: Você provavelmente poderia apenas fazer:

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

Mas o último só funciona se a matriz contiver valores exclusivos. Procurar 1 em "143" dará falso positivo, metinks.

Um pouco tarde, mas você pode usar isso:

#!/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

Eu vim com este, que acaba funcionando apenas no zsh, mas acho que a abordagem geral é boa.

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

Você remove seu padrão de cada elemento apenas se ele começar ${arr[@]/#pattern/}ou terminar ${arr[@]/%pattern/}com ele. Essas duas substituições funcionam no bash, mas ambas ao mesmo tempo${arr[@]/#%pattern/} funcionam apenas no zsh.

Se a matriz modificada for igual ao original, ela não conterá o elemento

Editar:

Este funciona no bash:

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

Após a substituição, ele compara o comprimento de ambas as matrizes. Obviamente, se a matriz contiver o elemento, a substituição a excluirá completamente e a contagem será diferente.