Comment trouver des modèles sur plusieurs lignes en utilisant grep?

Je veux trouver les fichiers qui ont "abc" ET "efg" dans cet ordre, et ces deux chaînes sont sur des lignes différentes dans ce fichier. Par exemple: un fichier avec du contenu:

blah blah..
blah blah..
blah abc blah
blah blah..
blah blah..
blah blah..
blah efg blah blah
blah blah..
blah blah..

Doit être apparié.

Grep n'est pas suffisant pour cette opération.

pcregrep qui se trouve dans la plupart des systèmes Linux modernes peut être utilisé comme

pcregrep -M  'abc.*(\n|.)*efg' test.txt

où -M, --multiline autoriser les motifs à correspondre à plusieurs lignes

Il existe également un nouveau pcre2grep . Les deux sont fournis par le projet PCRE .

pcre2grep est disponible pour Mac OS X via les ports Mac dans le cadre du port pcre2:

% sudo port install pcre2 

et via Homebrew comme:

% brew install pcre

ou pour pcre2

% brew install pcre2

pcre2grep est également disponible sur Linux (Ubuntu 18.04+)

$ sudo apt install pcre2-utils # PCRE2
$ sudo apt install pcregrep    # Older PCRE

Je ne sais pas si c'est possible avec grep, mais sed le rend très facile:

sed -e '/abc/,/efg/!d' [file-with-content]

Voici une solution inspirée de cette réponse :

• si 'abc' et 'efg' peuvent être sur la même ligne:

  grep -zl 'abc.*efg' <your list of files>

• si 'abc' et 'efg' doivent être sur des lignes différentes:

  grep -Pzl '(?s)abc.*\n.*efg' <your list of files>

Paramètres:

• -zTraitez l'entrée comme un ensemble de lignes, chacune se terminant par un octet zéro au lieu d'une nouvelle ligne. c'est-à-dire que grep traite l'entrée comme une seule grande ligne.

• -l nom d'impression de chaque fichier d'entrée à partir duquel la sortie aurait normalement été imprimée.

• (?s)activer PCRE_DOTALL, ce qui signifie que '.' trouve n'importe quel caractère ou nouvelle ligne.

sed devrait suffire comme l'a indiqué LJ ci-dessus,

au lieu de! d, vous pouvez simplement utiliser p pour imprimer:

sed -n '/abc/,/efg/p' file

Je me suis beaucoup appuyé sur pcregrep, mais avec le grep plus récent, vous n'avez pas besoin d'installer pcregrep pour la plupart de ses fonctionnalités. Utilisez simplement grep -P.

Dans l'exemple de la question du PO, je pense que les options suivantes fonctionnent bien, avec la deuxième meilleure correspondance avec la façon dont je comprends la question:

grep -Pzo "abc(.|\n)*efg" /tmp/tes*
grep -Pzl "abc(.|\n)*efg" /tmp/tes*

J'ai copié le texte sous / tmp / test1 et supprimé le «g» et enregistré sous / tmp / test2. Voici la sortie montrant que la première affiche la chaîne correspondante et la seconde ne montre que le nom de fichier (typique -o est pour montrer la correspondance et typique -l est pour montrer seulement le nom de fichier). Notez que le «z» est nécessaire pour les multilignes et le «(. | \ N)» signifie correspondre à «autre chose que la nouvelle ligne» ou «nouvelle ligne» - c'est-à-dire n'importe quoi:

user@host:~$ grep -Pzo "abc(.|\n)*efg" /tmp/tes*
/tmp/test1:abc blah
blah blah..
blah blah..
blah blah..
blah efg
user@host:~$ grep -Pzl "abc(.|\n)*efg" /tmp/tes*
/tmp/test1

Pour déterminer si votre version est suffisamment nouvelle, exécutez man grepet voyez si quelque chose de similaire apparaît en haut:

   -P, --perl-regexp
          Interpret  PATTERN  as a Perl regular expression (PCRE, see
          below).  This is highly experimental and grep -P may warn of
          unimplemented features.

Cela vient de GNU grep 2.10.

Cela peut être fait facilement en utilisant d'abord trpour remplacer les sauts de ligne par un autre caractère:

tr '\n' '\a' | grep -o 'abc.*def' | tr '\a' '\n'

Ici, j'utilise le caractère d'alarme \a(ASCII 7) à la place d'une nouvelle ligne. Cela ne se trouve presque jamais dans votre texte et greppeut le faire correspondre avec un ., ou le faire correspondre spécifiquement avec \a.

awk one-liner:

awk '/abc/,/efg/' [file-with-content]

Vous pouvez le faire très facilement si vous pouvez utiliser Perl.

perl -ne 'if (/abc/) { $abc = 1; next }; print "Found in $ARGV\n" if ($abc && /efg/); }' yourfilename.txt

Vous pouvez également le faire avec une seule expression régulière, mais cela implique de prendre tout le contenu du fichier dans une seule chaîne, ce qui pourrait finir par occuper trop de mémoire avec des fichiers volumineux. Pour être complet, voici cette méthode:

perl -e '@lines = <>; $content = join("", @lines); print "Found in $ARGV\n" if ($content =~ /abc.*efg/s);' yourfilename.txt

Je ne sais pas comment je ferais ça avec grep, mais je ferais quelque chose comme ça avec awk:

awk '/abc/{ln1=NR} /efg/{ln2=NR} END{if(ln1 && ln2 && ln1 < ln2){print "found"}else{print "not found"}}' foo

Cependant, vous devez faire attention à la façon dont vous procédez. Voulez-vous que l'expression régulière corresponde à la sous-chaîne ou au mot entier? ajoutez des balises \ w selon le cas. De plus, bien que cela soit strictement conforme à la façon dont vous avez indiqué l'exemple, cela ne fonctionne pas tout à fait lorsque abc apparaît une deuxième fois après efg. Si vous voulez gérer cela, ajoutez un si approprié dans le cas / abc / etc.

Malheureusement, vous ne pouvez pas. De la grepdocumentation:

grep recherche les FICHIERS d'entrée nommés (ou l'entrée standard si aucun fichier n'est nommé, ou si un seul trait d'union moins (-) est donné comme nom de fichier) pour les lignes contenant une correspondance avec le MOTIF donné.

Si vous êtes prêt à utiliser des contextes, cela peut être réalisé en tapant

grep -A 500 abc test.txt | grep -B 500 efg

Cela affichera tout entre "abc" et "efg", tant qu'ils sont à moins de 500 lignes les uns des autres.

Si vous avez besoin que les deux mots soient proches l'un de l'autre, par exemple pas plus de 3 lignes, vous pouvez le faire:

find . -exec grep -Hn -C 3 "abc" {} \; | grep -C 3 "efg"

Même exemple mais filtrant uniquement les fichiers * .txt:

find . -name *.txt -exec grep -Hn -C 3 "abc" {} \; | grep -C 3 "efg"

Et vous pouvez également remplacer la grepcommande par la egrepcommande si vous souhaitez également rechercher des expressions régulières.

Il y a quelques jours, j'ai publié une alternative à grep qui prend en charge cela directement, soit via une correspondance multiligne ou en utilisant des conditions - j'espère que cela sera utile pour certaines personnes qui recherchent ici. Voici à quoi ressembleraient les commandes de l'exemple:

Multiligne:

sift -lm 'abc.*efg' testfile

Conditions:

sift -l 'abc' testfile --followed-by 'efg'

Vous pouvez également spécifier que 'efg' doit suivre 'abc' sur un certain nombre de lignes:

sift -l 'abc' testfile --followed-within 5:'efg'

Vous pouvez trouver plus d'informations sur sift-tool.org .

Bien que l'option sed soit la plus simple et la plus facile, la doublure monocoque de LJ n'est malheureusement pas la plus portable. Ceux qui sont coincés avec une version du C Shell devront échapper à leur frange:

sed -e '/abc/,/efg/\!d' [file]

Malheureusement, cela ne fonctionne pas dans bash et al.

#!/bin/bash
shopt -s nullglob
for file in *
do
 r=$(awk '/abc/{f=1}/efg/{g=1;exit}END{print g&&f ?1:0}' file)
 if [ "$r" -eq 1 ];then
   echo "Found pattern in $file"
 else
   echo "not found"
 fi
done

vous pouvez utiliser grep au cas où vous ne souhaitez pas dans la séquence du motif.

grep -l "pattern1" filepattern*.* | xargs grep "pattern2"

exemple

grep -l "vector" *.cpp | xargs grep "map"

grep -ltrouvera tous les fichiers qui correspondent au premier modèle, et xargs recherchera le deuxième modèle. J'espère que cela t'aides.

Avec chercheur d'argent :

ag 'abc.*(\n|.)*efg'

similaire à la réponse du porteur de l'anneau, mais avec ag ​​à la place. Les avantages de vitesse du chercheur d'argent pourraient éventuellement briller ici.

J'ai utilisé cela pour extraire une séquence fasta d'un fichier multi fasta en utilisant l'option -P pour grep:

grep -Pzo ">tig00000034[^>]+"  file.fasta > desired_sequence.fasta

• P pour les recherches basées sur perl
• z pour faire une fin de ligne sur 0 octet plutôt que le caractère de nouvelle ligne
• o pour capturer simplement ce qui correspond puisque grep renvoie la ligne entière (ce qui dans ce cas puisque vous avez fait -z est le fichier entier).

Le noyau de l'expression rationnelle est le [^>]qui se traduit par "pas plus grand que le symbole"

Comme alternative à la réponse de Balu Mohan, il est possible d'imposer l'ordre des modèles en utilisant uniquement grep, headet tail:

for f in FILEGLOB; do tail $f -n +$(grep -n "pattern1" $f | head -n1 | cut -d : -f 1) 2>/dev/null | grep "pattern2" &>/dev/null && echo $f; done

Celui-ci n'est cependant pas très joli. Format plus lisible:

for f in FILEGLOB; do
    tail $f -n +$(grep -n "pattern1" $f | head -n1 | cut -d : -f 1) 2>/dev/null \
    | grep -q "pattern2" \
    && echo $f
done

Cela affichera les noms de tous les fichiers où "pattern2"apparaît après "pattern1", ou où les deux apparaissent sur la même ligne :

$ echo "abc
def" > a.txt
$ echo "def
abc" > b.txt
$ echo "abcdef" > c.txt; echo "defabc" > d.txt
$ for f in *.txt; do tail $f -n +$(grep -n "abc" $f | head -n1 | cut -d : -f 1) 2>/dev/null | grep -q "def" && echo $f; done
a.txt
c.txt
d.txt

Explication

• tail -n +i- imprimer toutes les lignes après le ie, inclus
• grep -n - ajouter des lignes correspondantes avec leurs numéros de ligne
• head -n1 - imprimer uniquement la première ligne
• cut -d : -f 1- imprimer la première colonne coupée en utilisant :comme délimiteur
• 2>/dev/null- tailsortie d'erreur de silence qui se produit si l' $()expression retourne vide
• grep -q- taire grepet retourner immédiatement si une correspondance est trouvée, car nous ne sommes intéressés que par le code de sortie

Cela devrait aussi marcher?!

perl -lpne 'print $ARGV if /abc.*?efg/s' file_list

$ARGVcontient le nom du fichier en cours lors de la lecture des file_list /srecherches de modificateurs sur la nouvelle ligne.

Le modèle de fichier *.shest important pour empêcher l'inspection des répertoires. Bien sûr, un test pourrait également empêcher cela.

for f in *.sh
do
  a=$( grep -n -m1 abc $f )
  test -n "${a}" && z=$( grep -n efg $f | tail -n 1) || continue 
  (( ((${z/:*/}-${a/:*/})) > 0 )) && echo $f
done

le

grep -n -m1 abc $f 

recherche au maximum 1 correspondance et renvoie (-n) le numéro de lin. Si une correspondance a été trouvée (test -n ...) trouver la dernière correspondance de efg (trouver tout et prendre la dernière avec queue -n 1).

z=$( grep -n efg $f | tail -n 1)

sinon continuer.

Puisque le résultat est quelque chose comme 18:foofile.sh String alf="abc";nous devons couper de ":" jusqu'à la fin de la ligne.

((${z/:*/}-${a/:*/}))

Devrait retourner un résultat positif si la dernière correspondance de la 2e expression est passée la première correspondance de la première.

Ensuite, nous rapportons le nom de fichier echo $f.

Pourquoi pas quelque chose de simple comme:

egrep -o 'abc|efg' $file | grep -A1 abc | grep efg | wc -l

renvoie 0 ou un entier positif.

egrep -o (affiche uniquement les correspondances, astuce: plusieurs correspondances sur la même ligne produisent une sortie multiligne comme si elles se trouvaient sur des lignes différentes)

• grep -A1 abc (imprimer abc et la ligne après)

• grep efg | wc -l (Nombre 0-n de lignes efg trouvées après abc sur la même ligne ou sur les lignes suivantes, le résultat peut être utilisé dans un "si")

• grep peut être changé en egrep etc. si une correspondance de modèle est nécessaire

Si vous avez une estimation de la distance entre les 2 chaînes 'abc' et 'efg' que vous recherchez, vous pouvez utiliser:

grep -r . -e 'abc' -A num1 -B num2 | grep 'efg'

De cette façon, le premier grep retournera la ligne avec les lignes 'abc' plus # num1 après, et # num2 lignes après, et le second grep passera en revue toutes ces lignes pour obtenir le 'efg'. Vous saurez alors dans quels fichiers ils apparaissent ensemble.

Avec ugrep sorti il ​​y a quelques mois:

ugrep 'abc(\n|.)+?efg'

Cet outil est hautement optimisé pour la vitesse. Il est également compatible GNU / BSD / PCRE-grep.

Notez que nous devons utiliser une répétition paresseuse +?, sauf si vous voulez faire correspondre toutes les lignes avec efgjusqu'à la dernière efgdu fichier.

Cela devrait fonctionner:

cat FILE | egrep 'abc|efg'

S'il y a plus d'une correspondance, vous pouvez filtrer en utilisant grep -v