Le tableau 1 contient-il l'une des chaînes du tableau 2

Pour vérifier si array1 contient une entrée de array2 , vous pouvez utiliser grep . Ce sera beaucoup plus rapide et plus court que les boucles dans bash.

Les commandes suivantes se terminent avec le code d'état 0 si et seulement s'il y a une correspondance. Utilisez-les comme ...

printf %q\\n "${array1[@]}" | grep -qFxf <(printf %q\\n "${array2[@]}")

Entrées de tableau sur une seule ligne

La version simple pour les chaînes sans saut de ligne est

printf %s\\n "${array1[@]}" | grep -qFxf <(printf %s\\n "${array2[@]}")

Pour les éléments de tableau qui ne contiennent pas de nouvelles lignes, le grep -qf avec printf "% s \ n" serait une bonne option. Pour comparer des tableaux avec n'importe quel élément, j'ai terminé par ceci:

printf "%s\0" "${array1[@]}" | eval grep -qzFx "$(printf " -e %q" "${array2[@]}")"

Le printf "% s \ 0" "$ {array [@]}" | sort -z affiche une liste triée de zéro élément de tableau terminé. Le comm -z12 extrait ensuite les éléments communs dans les deux listes. Le cmp -s / dev / null vérifie si la sortie de comm est vide, qui ne sera pas vide si un élément est dans les deux listes. Vous pouvez utiliser [-z "$ (comm -z ...)"] pour vérifier si la sortie de comm serait vide, mais bash se plaindra que la sortie d'une commande capturée avec $ (..) contient un octet nul, il est donc préférable de cmp -s /dev/null.

Je pense | est plus rapide que , donc votre if pourrait être:

if ! printf "%s\0" "${array1[@]}" | sort -z |
     comm -z12 - <(printf "%s\0" "${array2[@]}" | sort -z) |
     cmp -s /dev/null -; then
        echo "Some elements are in both array1 and array2"
fi

Ce qui suit pourrait fonctionner:

cmp -s /dev/null <(comm -z12 <(printf "%s\0" "${array1[@]}" | sort -z) <(printf "%s\0" "${array2[@]}" | sort -z))

Mais je crois avoir trouvé un bogue dans grep v3.1 lors de la correspondance d'un caractère de nouvelle ligne avec -x drapeau. Si vous n'utilisez pas le caractère de nouvelle ligne, la ligne ci-dessus fonctionne.

Pour une solution rapide, il vaut mieux utiliser un outil externe capable de traiter l'ensemble du tableau dans son ensemble (comme les réponses basées sur grep ). Faire des boucles imbriquées en bash pur est susceptible d'être plus lent pour toute quantité substantielle de données (où le traitement élément par élément dans bash est susceptible d'être plus coûteux que le

Cependant, si vous avez besoin d’une solution bash pure, je vois que votre solution actuelle n’a aucun moyen d’imprimer le " aucun match "scénario. De plus, il peut afficher "match" plusieurs fois.

Pour résoudre ce problème, vous pouvez simplement stocker le fait qu'une correspondance a été trouvée et l'utiliser pour les deux:

• quitter la boucle externe plus tôt ainsi que la boucle interne; et
• affiche la chaîne correcte à la fin.

Pour ce faire, vous pouvez utiliser quelque chose comme:

#!/bin/bash

# Test data.

array1=(a b c 1 2 3)
array2=(b 1)

# Default to not-found state.

foundMatch=false
for a in "${array1[@]}" ; do
    for b in "${array2[@]}" ; do
        # Any match switches to found state and exits inner loop.

        [[ "$a" == "$b" ]] && foundMatch=true && break
    done

    # If found, exit outer loop as well.

    ${foundMatch} && break
done

# Output appropriate message for found/not-found state.

$foundMatch && echo "Match" || echo "No match"

Voulez-vous essayer ce qui suit:

array1=(a b c 1 2 3)
array2=(b 1)

declare -A seen    # set marks of the elements of array1
for b in "${array2[@]}"; do
    (( seen[$b]++ ))
done

for a in "${array1[@]}"; do
    (( ${seen[$a]} )) && echo "match" && exit
done
echo "no match"