Wie finde ich mit grep Muster über mehrere Zeilen hinweg?

Ich möchte Dateien finden, die "abc" UND "efg" in dieser Reihenfolge haben, und diese beiden Zeichenfolgen befinden sich in dieser Datei in unterschiedlichen Zeilen. ZB: eine Datei mit Inhalt:

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

Sollte abgestimmt sein.

Grep reicht für diesen Vorgang nicht aus.

pcregrep, das in den meisten modernen Linux-Systemen zu finden ist, kann als verwendet werden

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

wo -M, --multiline erlauben Muster mehr als eine Zeile passen

Es gibt auch einen neueren pcre2grep . Beide werden vom PCRE-Projekt bereitgestellt .

pcre2grep ist für Mac OS X über Mac-Ports als Teil des Ports verfügbar pcre2:

% sudo port install pcre2 

und über Homebrew als:

% brew install pcre

oder für pcre2

% brew install pcre2

pcre2grep ist auch unter Linux verfügbar (Ubuntu 18.04+)

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

Ich bin mir nicht sicher, ob es mit grep möglich ist, aber sed macht es sehr einfach:

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

Hier ist eine Lösung, die von dieser Antwort inspiriert ist :

• wenn 'abc' und 'efg' in derselben Zeile stehen können:

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

• wenn 'abc' und 'efg' in unterschiedlichen Zeilen stehen müssen:

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

Parameter:

• -zBehandeln Sie die Eingabe als eine Reihe von Zeilen, die jeweils durch ein Null-Byte anstelle einer neuen Zeile abgeschlossen werden. dh grep behandelt die Eingabe als eine große Zeile.

• -l Druckname jeder Eingabedatei, aus der normalerweise die Ausgabe gedruckt worden wäre.

• (?s)aktiviere PCRE_DOTALL, was bedeutet, dass '.' findet ein Zeichen oder eine neue Zeile.

sed sollte als oben angegebenes Poster LJ ausreichen,

anstelle von! d können Sie einfach p zum Drucken verwenden:

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

Ich habe mich stark auf pcregrep verlassen, aber mit neuerem grep müssen Sie pcregrep für viele seiner Funktionen nicht installieren. Einfach benutzen grep -P.

Im Beispiel der OP-Frage denke ich, dass die folgenden Optionen gut funktionieren, wobei die zweitbeste zu meinem Verständnis der Frage passt:

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

Ich habe den Text als / tmp / test1 kopiert und das 'g' gelöscht und als / tmp / test2 gespeichert. Hier ist die Ausgabe, die zeigt, dass die erste die übereinstimmende Zeichenfolge und die zweite nur den Dateinamen anzeigt (typisch -o zeigt Übereinstimmung an und typisch -l zeigt nur Dateinamen an). Beachten Sie, dass das 'z' für mehrzeilig erforderlich ist und das '(. | \ N)' bedeutet, dass entweder 'irgendetwas anderes als Zeilenumbruch' oder 'Zeilenumbruch' übereinstimmt - dh alles:

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

Um festzustellen, ob Ihre Version neu genug ist, führen Sie sie aus man grepund prüfen Sie, ob oben etwas Ähnliches angezeigt wird:

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

Das ist aus GNU grep 2.10.

Dies kann einfach durchgeführt werden, indem zuerst trdie Zeilenumbrüche durch ein anderes Zeichen ersetzt werden:

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

Hier verwende ich das Alarmzeichen \a(ASCII 7) anstelle einer neuen Zeile. Dies wird in Ihrem Text fast nie gefunden und grepkann mit einem .oder speziell mit einem übereinstimmen \a.

awk Einzeiler:

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

Sie können dies sehr einfach tun, wenn Sie Perl verwenden können.

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

Sie können dies auch mit einem einzelnen regulären Ausdruck tun. Dazu muss jedoch der gesamte Inhalt der Datei in einer einzigen Zeichenfolge zusammengefasst werden, was bei großen Dateien möglicherweise zu viel Speicherplatz beansprucht. Der Vollständigkeit halber ist hier diese Methode:

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

Ich weiß nicht, wie ich das mit grep machen würde, aber ich würde so etwas mit awk machen:

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

Sie müssen jedoch vorsichtig sein, wie Sie dies tun. Möchten Sie, dass die Regex mit der Teilzeichenfolge oder dem gesamten Wort übereinstimmt? Fügen Sie gegebenenfalls \ w Tags hinzu. Auch wenn dies genau dem entspricht, wie Sie das Beispiel angegeben haben, funktioniert es nicht ganz, wenn abc ein zweites Mal nach efg erscheint. Wenn Sie damit umgehen möchten, fügen Sie im Fall / abc / usw. ein Gegebenenfalls hinzu.

Das kannst du leider nicht. Aus den grepDokumenten:

grep durchsucht die benannten Eingabedateien (oder die Standardeingabe, wenn keine Dateien benannt sind oder wenn ein einzelnes Bindestrich-Minus (-) als Dateiname angegeben wird) nach Zeilen, die eine Übereinstimmung mit dem angegebenen MUSTER enthalten.

Wenn Sie bereit sind, Kontexte zu verwenden, kann dies durch Eingabe erreicht werden

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

Dies zeigt alles zwischen "abc" und "efg" an, solange sie innerhalb von 500 Zeilen voneinander liegen.

Wenn Sie möchten, dass beide Wörter nahe beieinander liegen, z. B. nicht mehr als 3 Zeilen, können Sie dies tun:

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

Gleiches Beispiel, aber nur * .txt-Dateien filtern:

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

Außerdem können Sie den grepBefehl durch einen egrepBefehl ersetzen, wenn Sie auch reguläre Ausdrücke suchen möchten.

Ich habe vor einigen Tagen eine grep-Alternative veröffentlicht, die dies direkt unterstützt, entweder durch mehrzeiliges Matching oder unter Verwendung von Bedingungen - hoffentlich ist es für einige Leute nützlich, die hier suchen. So würden die Befehle für das Beispiel aussehen:

Mehrzeilig:

sift -lm 'abc.*efg' testfile

Bedingungen:

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

Sie können auch angeben, dass 'efg' innerhalb einer bestimmten Anzahl von Zeilen auf 'abc' folgen muss:

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

Weitere Informationen finden Sie auf sift-tool.org .

Während die sed-Option die einfachste und einfachste ist, ist der Einzeiler von LJ leider nicht die tragbarste. Diejenigen, die mit einer Version der C-Shell feststecken, müssen ihrem Pony entkommen:

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

Dies funktioniert bei bash et al. Leider nicht.

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

Sie können grep verwenden, falls Sie nicht an der Reihenfolge des Musters interessiert sind.

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

Beispiel

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

grep -lfindet alle Dateien, die mit dem ersten Muster übereinstimmen, und xargs sucht nach dem zweiten Muster. Hoffe das hilft.

Mit Silbersucher :

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

ähnlich der Antwort des Ringträgers, aber stattdessen mit ag. Geschwindigkeitsvorteile von Silver Searcher könnten hier möglicherweise glänzen.

Ich habe dies verwendet, um eine Fasta-Sequenz aus einer Multi-Fasta-Datei mit der Option -P für grep zu extrahieren:

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

• P für perlbasierte Suchen
• z, damit eine Zeile mit 0 Byte und nicht mit Zeilenumbruch endet
• o um nur zu erfassen, was übereinstimmt, da grep die gesamte Zeile zurückgibt (was in diesem Fall, seit Sie -z getan haben, die gesamte Datei ist).

Der Kern des regulären Ausdrucks ist der, [^>]der "nicht größer als das Symbol" bedeutet.

Als Alternative zu Balu Mohan Antwort ist es möglich , die Reihenfolge der Muster nur mit zu erzwingen grep, headund 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

Dieser ist allerdings nicht sehr hübsch. Lesbarer formatiert:

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

Dadurch werden die Namen aller Dateien drucken , wo "pattern2"nach erscheint "pattern1", oder wo beide erscheinen auf der gleichen Linie :

$ 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

Erläuterung

• tail -n +i- Alle Zeilen nach dem ith einschließlich drucken
• grep -n - Stellen Sie übereinstimmende Zeilen mit ihren Zeilennummern voran
• head -n1 - Nur die erste Zeile drucken
• cut -d : -f 1- Drucken Sie die erste Schnittspalte :als Trennzeichen
• 2>/dev/null- Stummschaltungsfehlerausgabe tail, die auftritt, wenn der $()Ausdruck leer zurückgegeben wird
• grep -q- Schweigen grepund sofort zurückkehren, wenn eine Übereinstimmung gefunden wird, da wir nur am Exit-Code interessiert sind

Das sollte auch funktionieren?!

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

$ARGVEnthält den Namen der aktuellen Datei beim Lesen von file_list /sModifikatorsuchen über Zeilenumbrüche.

Das Dateimuster *.shist wichtig, um zu verhindern, dass Verzeichnisse überprüft werden. Natürlich könnte auch ein Test dies verhindern.

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

Das

grep -n -m1 abc $f 

sucht maximal 1 Matching und gibt (-n) die Leinennummer zurück. Wenn eine Übereinstimmung gefunden wurde (test -n ...), finde die letzte Übereinstimmung von efg (finde alle und nimm die letzte mit Schwanz -n 1).

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

sonst weiter.

Da das Ergebnis so etwas wie ist 18:foofile.sh String alf="abc";, müssen wir bis zum Zeilenende von ":" wegschneiden.

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

Sollte ein positives Ergebnis liefern, wenn die letzte Übereinstimmung des 2. Ausdrucks nach der ersten Übereinstimmung des ersten Ausdrucks liegt.

Dann melden wir den Dateinamen echo $f.

Warum nicht etwas Einfaches wie:

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

gibt 0 oder eine positive ganze Zahl zurück.

egrep -o (Zeigt nur Übereinstimmungen an, Trick: Mehrere Übereinstimmungen in derselben Zeile erzeugen eine mehrzeilige Ausgabe, als ob sie sich in verschiedenen Zeilen befinden.)

• grep -A1 abc (drucke abc und die Zeile danach)

• grep efg | wc -l (0-n Anzahl der nach abc in denselben oder folgenden Zeilen gefundenen efg-Zeilen, Ergebnis kann in einem 'if "verwendet werden)

• grep kann in egrep usw. geändert werden, wenn ein Mustervergleich erforderlich ist

Wenn Sie eine Schätzung über den Abstand zwischen den beiden gesuchten Zeichenfolgen 'abc' und 'efg' haben, können Sie Folgendes verwenden:

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

Auf diese Weise gibt der erste grep die Zeile mit den Zeilen 'abc' plus # num1 danach und den Zeilen # num2 danach zurück, und der zweite grep durchsucht alle Zeilen, um das 'efg' zu erhalten. Dann wissen Sie, bei welchen Dateien sie zusammen erscheinen.

Mit ugrep vor ein paar Monaten veröffentlicht:

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

Dieses Tool ist stark auf Geschwindigkeit optimiert. Es ist auch GNU / BSD / PCRE-grep-kompatibel.

Beachten Sie, dass wir eine verzögerte Wiederholung verwenden sollten +?, es sei denn, Sie möchten alle Zeilen efgbis zum letzten efgin der Datei miteinander abgleichen.

Das sollte funktionieren:

cat FILE | egrep 'abc|efg'

Wenn es mehr als eine Übereinstimmung gibt, können Sie mit grep -v herausfiltern