Dans Bash, quelle est la manière la plus simple de tester si un tableau contient une certaine valeur?

Edit : Avec l'aide des réponses et des commentaires, après quelques tests, j'ai trouvé ceci:

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

Je ne sais pas si c'est la meilleure solution, mais cela semble fonctionner.

Cette approche a l'avantage de ne pas avoir à boucler sur tous les éléments (du moins pas explicitement). Mais comme array_to_string_internal()dans array.c boucle toujours les éléments du tableau et les concatène en une chaîne, ce n'est probablement pas plus efficace que les solutions de bouclage proposées, mais c'est plus lisible.

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

Notez que dans les cas où la valeur que vous recherchez est l'un des mots d'un élément de tableau avec des espaces, cela donnera des faux positifs. Par exemple

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

Le regex verra "Jack" comme étant dans le tableau même s'il ne l'est pas. Vous devrez donc changer IFSet les caractères de séparation sur votre expression régulière si vous voulez toujours utiliser cette solution, comme celle-ci

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

Cela affichera "false".

Évidemment, cela peut également être utilisé comme une déclaration de test, ce qui permet de l'exprimer comme une ligne

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

Voici une petite fonction pour y parvenir. La chaîne de recherche est le premier argument et les autres sont les éléments du tableau:

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

Un test de cette fonction pourrait ressembler à:

$ 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

Pour les cordes:

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

Solution en une ligne

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

Explication

L' printfinstruction imprime chaque élément du tableau sur une ligne distincte.

L' grepinstruction utilise les caractères spéciaux ^et $pour trouver une ligne qui contient exactement le modèle donné comme mypattern(ni plus, ni moins).

Usage

Pour mettre cela dans une if ... thendéclaration:

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

J'ai ajouté un -qdrapeau à l' grepexpression pour qu'elle n'imprime pas les correspondances; cela traitera simplement l'existence d'une correspondance comme "vraie".

Si vous avez besoin de performances, vous ne voulez pas parcourir votre tableau entier à chaque fois que vous effectuez une recherche.

Dans ce cas, vous pouvez créer un tableau associatif (table de hachage ou dictionnaire) qui représente un index de ce tableau. C'est-à-dire qu'il mappe chaque élément du tableau dans son index dans le tableau:

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
}

Ensuite, vous pouvez l'utiliser comme ceci:

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

Et testez l'adhésion comme ceci:

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 aussi:

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

Notez que cette solution fait la bonne chose même s'il y a des espaces dans la valeur testée ou dans les valeurs du tableau.

En bonus, vous obtenez également l'index de la valeur dans le tableau avec:

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

J'utilise généralement juste:

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

une valeur non nulle indique qu'une correspondance a été trouvée.

Un autre liner sans fonction:

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

Merci @Qwerty pour les informations concernant les espaces!

fonction correspondante:

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

exemple:

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

Gère désormais correctement les tableaux vides.

Voici une petite contribution:

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

Remarque: cette façon ne distingue pas le cas "deux mots" mais ce n'est pas obligatoire dans la question.

Si vous voulez faire un test rapide et sale pour voir s'il vaut la peine d'itérer sur l'ensemble du tableau pour obtenir une correspondance précise, Bash peut traiter les tableaux comme des scalaires. Testez une correspondance dans le scalaire, si aucun, sauter la boucle permet de gagner du temps. De toute évidence, vous pouvez obtenir des faux positifs.

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

Cela produira "Vérification" et "Correspondance". Avec array=(word "two words" something)elle ne sortira que "Vérification". Avec array=(word "two widgets" something)il n'y aura pas de sortie.

Cela fonctionne pour moi:

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

Exemple d'appel:

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

Si vous préférez, vous pouvez utiliser des options longues équivalentes:

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

Empruntant à la réponse de Dennis Williamson , la solution suivante combine des tableaux, des citations shell-safe et des expressions régulières pour éviter d'avoir à: itérer sur les boucles; en utilisant des tuyaux ou d'autres sous-processus; ou en utilisant des utilitaires non 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

Le code ci-dessus fonctionne en utilisant des expressions régulières Bash pour correspondre à une version chaîne du contenu du tableau. Il existe six étapes importantes pour garantir que la correspondance d'expression régulière ne peut pas être dupée par des combinaisons intelligentes de valeurs dans le tableau:

1. Construire la chaîne de comparaison à l'aide Bash est construit en printfcoquille citant, %q. Les guillemets shell garantissent que les caractères spéciaux deviennent "shell-safe" en étant échappés avec une barre oblique inverse \.
2. Choisissez un caractère spécial pour servir de délimiteur de valeur. Le délimiteur DOIT être l'un des caractères spéciaux qui s'échapperont lors de l'utilisation %q; c'est la seule façon de garantir que les valeurs dans le tableau ne peuvent pas être construites de manière intelligente pour tromper la correspondance d'expression régulière. Je choisis une virgule, parce que ce personnage est le plus sûr lorsqu'il est évalué ou utilisé de manière inattendue.
3. Combinez tous les éléments du tableau en une seule chaîne, en utilisant deux instances du caractère spécial pour servir de délimiteur. En utilisant la virgule comme exemple, j'ai utilisé ,,%qcomme argument pour printf. Ceci est important car deux instances du caractère spécial ne peuvent apparaître l'une à côté de l'autre que lorsqu'elles apparaissent comme délimiteur; toutes les autres instances du caractère spécial seront échappées.
4. Ajoutez deux instances de fin du délimiteur à la chaîne pour autoriser les correspondances avec le dernier élément du tableau. Ainsi, au lieu de comparer contre ${array_str}, comparez contre ${array_str},,.
5. Si la chaîne cible que vous recherchez est fournie par une variable utilisateur, vous devez échapper toutes les instances du caractère spécial avec une barre oblique inverse. Sinon, la correspondance d'expression régulière devient vulnérable à être dupée par des éléments de tableau intelligemment conçus.
6. Effectuez une correspondance d'expression régulière Bash avec la chaîne.

Un petit ajout à la réponse de @ ghostdog74 sur l'utilisation de la caselogique pour vérifier que le tableau contient une valeur particulière:

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

Ou avec l' extgloboption activée, vous pouvez le faire comme ceci:

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

Nous pouvons également le faire avec une ifdéclaration:

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

donné :

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

puis une simple vérification de:

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

où

c is element separator
p is regex pattern

(La raison d'affecter p séparément, plutôt que d'utiliser l'expression directement à l'intérieur de [[]] est de maintenir la compatibilité pour bash 4)

En combinant quelques-unes des idées présentées ici, vous pouvez faire une déclaration élégante sans boucles qui correspond exactement aux mots .

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

Cela ne se déclenchera pas sur wordou val, seuls les mots entiers correspondront. Il se cassera si chaque valeur de tableau contient plusieurs mots.

J'écris généralement ce genre d'utilitaires pour opérer sur le nom de la variable, plutôt que sur la valeur de la variable, principalement parce que bash ne peut pas autrement transmettre des variables par référence.

Voici une version qui fonctionne avec le nom du tableau:

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
}

Avec cela, l'exemple de question devient:

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

etc.

Utilisation de grepetprintf

Formatez chaque membre du tableau sur une nouvelle ligne, puis greples lignes.

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

Notez que cela n'a aucun problème avec les délimètres et les espaces.

Vérification sur une ligne sans «grep» et boucles

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

Cette approche n'utilise ni utilitaires externes comme grepni boucles.

Ce qui se passe ici, c'est:

• nous utilisons un matcher de sous-chaîne générique pour trouver notre élément dans le tableau qui est concaténé dans une chaîne;
• nous supprimons les faux positifs possibles en enfermant notre élément de recherche entre une paire de délimiteurs;
• nous utilisons un caractère non imprimable comme délimiteur, par sécurité;
• nous obtenons que notre délimiteur soit également utilisé pour la concaténation de tableau par remplacement temporaire de la IFSvaleur de la variable;
• nous rendons ce IFSremplacement de valeur temporaire en évaluant notre expression conditionnelle dans un sous-shell (à l'intérieur d'une paire de parenthèses)

Utilisation de l'expansion des paramètres:

$ {paramètre: + mot} Si le paramètre est nul ou non défini, rien n'est substitué, sinon l'expansion de mot est substituée.

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

Après avoir répondu, j'ai lu une autre réponse qui m'a particulièrement plu, mais elle était imparfaite et dévalorisée. Je me suis inspiré et voici deux nouvelles approches que je vois viables.

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

en utilisant grepet printf:

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

utilisant for:

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

Pour les résultats non trouvés, ajoutez || <run_your_if_notfound_command_here>

Voici mon point de vue à ce sujet.

Je préfère ne pas utiliser de boucle bash for si je peux l'éviter, car cela prend du temps à s'exécuter. Si quelque chose doit boucler, que ce soit quelque chose qui a été écrit dans un langage de niveau inférieur à un script shell.

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

Cela fonctionne en créant un tableau associatif temporaire _arr, dont les indices sont dérivés des valeurs du tableau en entrée. (Notez que les tableaux associatifs sont disponibles dans bash 4 et supérieur, donc cette fonction ne fonctionnera pas dans les versions antérieures de bash.) Nous définissons$IFS pour éviter la division des mots sur les espaces.

La fonction ne contient pas de boucles explicites, bien que bash en interne parcourt le tableau d'entrée afin de remplir printf. Le format printf utilise %qpour garantir que les données d'entrée sont échappées de manière à pouvoir être utilisées en toute sécurité comme clés de tableau.

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

Notez que tout ce que cette fonction utilise est intégré à bash, donc il n'y a pas de canaux externes vous entraînant, même dans l'extension de commande.

Et si vous n'aimez pas utiliser eval... eh bien, vous êtes libre d'utiliser une autre approche. :-)

Ma version de la technique des expressions régulières qui a déjà été suggérée:

values=(foo bar)
requestedValue=bar

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

Ce qui se passe ici, c'est que vous développez la totalité du tableau des valeurs prises en charge en mots et ajoutez une chaîne spécifique, "X-" dans ce cas, à chacun d'eux, et faites de même à la valeur demandée. Si celui-ci est en effet contenu dans le tableau, alors la chaîne résultante correspondra tout au plus à l'un des jetons résultants, ou pas du tout au contraire. Dans ce dernier cas, le || déclencheurs d'opérateur et vous savez que vous avez affaire à une valeur non prise en charge. Avant tout cela, la valeur demandée est supprimée de tous les espaces blancs de début et de fin par une manipulation de chaîne shell standard.

C'est propre et élégant, je pense, bien que je ne sois pas trop sûr de la performance que cela peut être si votre tableau de valeurs prises en charge est particulièrement grand.

Voici mon point de vue sur ce problème. Voici la version courte:

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

Et la version longue, qui je pense est beaucoup plus agréable pour les yeux.

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

Exemples:

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

J'ai eu le cas où je devais vérifier si un ID était contenu dans une liste d'ID générés par un autre script / commande. Pour moi, a travaillé ce qui suit:

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

Vous pouvez également le raccourcir / le compacter comme ceci:

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

Dans mon cas, j'exécutais jq pour filtrer du JSON pour une liste d'ID et j'ai dû vérifier plus tard si mon ID était dans cette liste et cela a fonctionné le mieux pour moi. Cela ne fonctionnera pas pour les tableaux créés manuellement du type LIST=("1" "2" "4")mais pour les sorties de script séparées par des sauts de ligne.

PS: je n'ai pas pu commenter une réponse car je suis relativement nouveau ...

Le code suivant vérifie si une valeur donnée est dans le tableau et renvoie son décalage de base zéro:

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

La correspondance est effectuée sur les valeurs complètes, donc la définition de VALUE = "trois" ne correspondrait pas.

Cela pourrait valoir la peine d'être étudié si vous ne voulez pas répéter:

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

Extrait adapté de: http://www.thegeekstuff.com/2010/06/bash-array-tutorial/ Je pense que c'est assez intelligent.

EDIT: Vous pourriez probablement simplement faire:

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

Mais ce dernier ne fonctionne que si le tableau contient des valeurs uniques. Rechercher 1 sur "143" donnera des faux positifs, je pense.

Un peu tard, mais vous pouvez utiliser ceci:

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

Je suis venu avec celui-ci, qui ne fonctionne que dans zsh, mais je pense que l'approche générale est agréable.

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

Vous ne retirez votre motif de chaque élément que s'il commence ${arr[@]/#pattern/}ou se termine ${arr[@]/%pattern/}avec lui. Ces deux substitutions fonctionnent en bash, mais les deux en même temps${arr[@]/#%pattern/} ne fonctionnent qu'en zsh.

Si le tableau modifié est égal à l'original, il ne contient pas l'élément.

Éditer:

Celui-ci fonctionne en bash:

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

Après la substitution, il compare la longueur des deux tableaux. Obly si le tableau contient l'élément, la substitution le supprimera complètement et le nombre sera différent.