Comment exécuter grep avec plusieurs modèles AND?

Je voudrais obtenir la correspondance de modèle multiple avec AND implicite entre les modèles, c'est-à-dire l'équivalent d'exécuter plusieurs greps dans une séquence:

grep pattern1 | grep pattern2 | ...

Alors, comment le convertir en quelque chose comme?

grep pattern1 & pattern2 & pattern3

Je voudrais utiliser un seul grep car je construis des arguments de manière dynamique, donc tout doit tenir dans une chaîne. Utiliser filter est une fonctionnalité système, pas grep, donc ce n’est pas un argument.

Ne confondez pas cette question avec:

grep "pattern1\|pattern2\|..."

Ceci est une correspondance multi-motifs OU .

agrep peut le faire avec cette syntaxe:

agrep 'pattern1;pattern2'

Avec GNU grep, une fois construit avec le support PCRE, vous pouvez faire:

grep -P '^(?=.*pattern1)(?=.*pattern2)'

Avec astgrep :

grep -X '.*pattern1.*&.*pattern2.*'

(ajout .*s comme <x>&<y>les chaînes de caractères qui correspondent à la fois <x>et <y> exactement , a&bne correspondra jamais à car il n'y a pas une telle chaîne qui peut être à la fois aet ben même temps).

Si les motifs ne se chevauchent pas, vous pourrez peut-être aussi:

grep -e 'pattern1.*pattern2' -e 'pattern2.*pattern1'

Le meilleur moyen portable est probablement avec awkcomme déjà mentionné:

awk '/pattern1/ && /pattern2/'

Avec sed:

sed -e '/pattern1/!d' -e '/pattern2/!d'

Veuillez noter que tous ceux-ci auront une syntaxe d'expression régulière différente.

Vous n'avez pas spécifié la version de grep, c'est important. Certains moteurs d’expression rationnelle autorisent plusieurs correspondances groupées par AND en utilisant '&', mais il s’agit d’une fonctionnalité non standard et non portable. Mais au moins GNU, grep ne le supporte pas.

OTOH vous pouvez simplement remplacer grep par sed, awk, perl, etc. (énumérés par ordre croissant de poids). Avec awk, la commande ressemblerait à

awk '/ regexp1 / && / regexp2 / && / regexp3 / {print; } '

et il peut être construit pour être spécifié en ligne de commande de manière simple.

Si patternscontient un motif par ligne, vous pouvez faire quelque chose comme ceci:

awk 'NR==FNR{a[$0];next}{for(i in a)if($0!~i)next}1' patterns -

Ou cela correspond à des sous-chaînes au lieu d'expressions régulières:

awk 'NR==FNR{a[$0];next}{for(i in a)if(!index($0,i))next}1' patterns -

Pour imprimer toutes les entrées au lieu de pas de lignes dans le cas patternsvide, remplacer NR==FNRpar FILENAME==ARGV[1]ou par ARGIND==1dans gawk.

Ces fonctions impriment les lignes de STDIN contenant chaque chaîne spécifiée en tant qu'argument en tant que sous-chaîne. gasignifie grep all et gaiignore la casse.

ga(){ awk 'FILENAME==ARGV[1]{a[$0];next}{for(i in a)if(!index($0,i))next}1' <(printf %s\\n "$@") -; }
gai(){ awk 'FILENAME==ARGV[1]{a[tolower($0)];next}{for(i in a)if(!index(tolower($0),i))next}1' <(printf %s\\n "$@") -; }

Ce n'est pas une très bonne solution mais illustre un "truc" plutôt cool

function chained-grep {
    local pattern="$1"
    if [[ -z "$pattern" ]]; then
        cat
        return
    fi    

    shift
    grep -- "$pattern" | chained-grep "$@"
}

cat something | chained-grep all patterns must match order but matter dont

git grep

Voici la syntaxe qui consiste à git grepcombiner plusieurs modèles à l' aide d' expressions booléennes :

git grep --no-index -e pattern1 --and -e pattern2 --and -e pattern3

^{La commande ci-dessus imprimera des lignes correspondant à tous les motifs à la fois.}

--no-index Rechercher dans le répertoire en cours des fichiers qui ne sont pas gérés par Git.

Vérifier l' man git-grepaide.

Voir également:

• Comment utiliser grep pour correspondre à string1 AND string2?
• Vérifiez si toutes les chaînes ou les expressions rationnelles existent dans un fichier .

Pour le fonctionnement OR , voir:

• Comment puis-je grep pour plusieurs motifs avec des motifs ayant un caractère pipe?
• Grep: comment ajouter une condition "OU"?

ripgrep

Voici l'exemple utilisant rg:

rg -N '(?P<p1>.*pattern1.*)(?P<p2>.*pattern2.*)(?P<p3>.*pattern3.*)' file.txt

C’est l’un des outils de recherche les plus rapides, car il est construit sur le moteur de regex de Rust qui utilise des automates finis, SIMD et des optimisations littérales agressives pour rendre la recherche très rapide.

^{Voir également la demande de fonctionnalités associée sur GH-875 .}

Voici ma prise, et cela fonctionne pour les mots sur plusieurs lignes:

Utilisez find . -type fsuivi du maximum
-exec grep -q 'first_word' {} \;
et du dernier mot clé avec
-exec grep -l 'nth_word' {} \;

-q
-lfichiers de spectacle silencieux / silencieux avec correspondances

La liste suivante retourne la liste des noms de fichiers avec les mots "lapin" et "trou":
find . -type f -exec grep -q 'rabbit' {} \; -exec grep -l 'hole' {} \;

Pour rechercher TOUS les mots (ou modèles), vous pouvez exécuter grep dans la boucle FOR . Le principal avantage ici est la recherche dans une liste de regex .

EDITER ma réponse avec un exemple réel:

# search_all_regex_and_error_if_missing.sh 

find_list="\
^a+$ \
^b+$ \
^h+$ \
^d+$ \
"

for item in $find_list; do
   if grep -E "$item" file_to_search_within.txt 
   then
       echo "$item found in file."
   else
       echo "Error: $item not found in file. Exiting!"
       exit 1
   fi
done

Maintenant exécutons-le sur ce fichier:

hhhhhhhhhh

aaaaaaa

bbbbbbbbb

Ababbabaabbaaa

ccccccc

dsfsdf

bbbb

cccdd

aa

caa

# ./search_all_regex_and_error_if_missing.sh

aaaaaaa aa

^ a + $ trouvé dans le fichier.

bbbbbbbbb bbbb

^ b + $ trouvé dans le fichier.

hhhhhhhhhh

^ h + $ trouvé dans le fichier.

Erreur: ^ d + $ introuvable dans le fichier. En sortant!