Jak znaleźć wzory w wielu liniach za pomocą grep?

Chcę znaleźć pliki, które mają „abc” ORAZ „efg” w tej kolejności, a te dwa ciągi znajdują się w różnych wierszach tego pliku. Np .: plik z zawartością:

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

Powinny być dopasowane.

Grep nie jest wystarczający do tej operacji.

pcregrep, który znajduje się w większości współczesnych systemów Linux, może być używany jako

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

gdzie -M, --multiline pozwól wzorom dopasować więcej niż jedną linię

Istnieje również nowszy pcre2grep . Oba są dostarczane przez projekt PCRE .

pcre2grep jest dostępny dla Mac OS X poprzez porty Mac jako część portu pcre2:

% sudo port install pcre2 

i za pośrednictwem Homebrew jako:

% brew install pcre

lub dla pcre2

% brew install pcre2

pcre2grep jest również dostępny w systemie Linux (Ubuntu 18.04+)

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

Nie jestem pewien, czy jest to możliwe z grep, ale sed bardzo ułatwia:

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

Oto rozwiązanie inspirowane tą odpowiedzią :

• jeśli „abc” i „efg” mogą znajdować się w tej samej linii:

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

• jeśli „abc” i „efg” muszą znajdować się w różnych wierszach:

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

Params:

• -zTraktuj dane wejściowe jako zestaw wierszy zakończonych zerowym bajtem zamiast nowego wiersza. tzn. grep traktuje dane wejściowe jako jedną dużą linię.

• -l wypisz nazwę każdego pliku wejściowego, z którego normalnie wydrukowano by wyjście.

• (?s)aktywuj PCRE_DOTALL, co oznacza, że ​​„.” znajduje dowolny znak lub znak nowej linii.

sed powinno wystarczyć, jak napisano powyżej plakat LJ,

zamiast! d możesz po prostu użyć p, aby wydrukować:

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

W dużej mierze polegałem na pcregrep, ale w nowszym grep nie musisz instalować pcregrep dla wielu jego funkcji. Po prostu użyj grep -P.

W przykładzie pytania PO myślę, że następujące opcje działają dobrze, a drugi najlepiej pasuje do tego, jak rozumiem pytanie:

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

Skopiowałem tekst jako / tmp / test1 i usunąłem „g” i zapisałem jako / tmp / test2. Oto wynik pokazujący, że pierwszy pokazuje pasujący ciąg, a drugi pokazuje tylko nazwę pliku (typowe -o ma pokazywać dopasowanie, a typowe -l pokazuje tylko nazwę pliku). Zauważ, że „z” jest konieczne dla multilinii, a „(. | \ N)” oznacza dopasowanie „cokolwiek innego niż nowa linia” lub „nowa linia” - tj. Cokolwiek:

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

Aby ustalić, czy Twoja wersja jest wystarczająco nowa, uruchom man grepi sprawdź, czy coś podobnego do tego pojawia się u góry:

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

To pochodzi z GNU grep 2.10.

Można to łatwo zrobić, najpierw trzastępując znaki nowej linii inną postacią:

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

Tutaj używam znaku alarmu \a(ASCII 7) zamiast nowego wiersza. Tego prawie nigdy nie można znaleźć w tekście i grepmożna go dopasować za pomocą .lub specjalnie do niego \a.

awk one-liner:

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

Możesz to zrobić bardzo łatwo, jeśli możesz użyć Perla.

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

Możesz to zrobić również za pomocą jednego wyrażenia regularnego, ale wymaga to przeniesienia całej zawartości pliku do jednego ciągu, co może zająć zbyt dużo pamięci w przypadku dużych plików. Dla kompletności, oto ta metoda:

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

Nie wiem, jak zrobiłbym to z grep, ale zrobiłbym coś takiego z awk:

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

Musisz jednak uważać, jak to robisz. Czy chcesz, aby wyrażenie regularne pasowało do podłańcucha czy całego słowa? dodaj odpowiednio tagi \ w. Ponadto, chociaż jest to ściśle zgodne z tym, co podałeś w przykładzie, nie działa całkiem, gdy abc pojawia się drugi raz po efg. Jeśli chcesz sobie z tym poradzić, dodaj jeśli to właściwe w / abc / case itp.

Niestety nie możesz. Z grepdokumentów:

grep przeszukuje nazwane PLIKI wejściowe (lub standardowe wejście, jeśli nie ma nazw plików lub jeśli jako nazwę pliku podano pojedynczy łącznik minus (-)) w poszukiwaniu linii zawierających dopasowanie do podanego WZORCA.

Jeśli chcesz używać kontekstów, możesz to osiągnąć, pisząc

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

Spowoduje to wyświetlenie wszystkiego między „abc” i „efg”, o ile znajdują się w odległości 500 linii od siebie.

Jeśli potrzebujesz, aby oba słowa były blisko siebie, na przykład nie więcej niż 3 linie, możesz to zrobić:

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

Ten sam przykład, ale filtrowanie tylko plików * .txt:

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

A także możesz zamienić greppolecenie na egreppolecenie, jeśli chcesz również znaleźć wyrażenia regularne.

Kilka dni temu wydałem alternatywę grep, która obsługuje to bezpośrednio, albo poprzez dopasowanie wieloliniowe, albo przy użyciu warunków - mam nadzieję, że przyda się niektórym osobom szukającym tutaj. Tak wyglądałyby polecenia dla przykładu:

Multiline:

sift -lm 'abc.*efg' testfile

Warunki:

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

Możesz również określić, że „efg” musi podążać za „abc” w określonej liczbie wierszy:

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

Możesz znaleźć więcej informacji na sift-tool.org .

Podczas gdy opcja sed jest najprostsza i najłatwiejsza, jednowarstwowa LJ niestety nie jest najbardziej przenośna. Ci, którzy utknęli z wersją pocisku C, będą musieli uciec od grzywki:

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

To niestety nie działa w bash i in.

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

możesz użyć polecenia grep, ponieważ nie jesteś zainteresowany sekwencją wzoru.

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

przykład

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

grep -lznajdzie wszystkie pliki, które pasują do pierwszego wzorca, a xargs będzie grepował dla drugiego wzorca. Mam nadzieję że to pomoże.

Ze srebrnym wyszukiwarką :

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

podobny do odpowiedzi na okaziciela dzwonka, ale zamiast niego z ag. Korzyści płynące ze srebrnej wyszukiwarki mogą tu zabłysnąć.

Użyłem tego do wyodrębnienia sekwencji fasta z pliku multi fasta przy użyciu opcji -P dla grep:

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

• P dla wyszukiwań opartych na perlu
• z do tworzenia końca linii w 0 bajtach zamiast znaku nowej linii
• o po prostu przechwytuje to, co pasuje, ponieważ grep zwraca całą linię (co w tym przypadku, ponieważ zrobiłeś -z, to cały plik).

Rdzeniem wyrażenia regularnego jest to, [^>]co przekłada się na „nie większy niż symbol”

Jako alternatywę dla odpowiedzi Balu Mohana, możliwe jest, aby wymusić kolejność wzorów przy użyciu tylko grep, headi 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

Ten jednak nie jest zbyt ładny. Sformatowane bardziej czytelnie:

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

To wypisuje nazwy wszystkich plików, w których "pattern2"pojawia się po "pattern1", lub w przypadku gdy obie pojawiają się na tej samej linii :

$ 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

Wyjaśnienie

• tail -n +i- wydrukuj wszystkie wiersze po ith, włącznie
• grep -n - poprzedzać pasujące linie ich numerami linii
• head -n1 - wydrukuj tylko pierwszy rząd
• cut -d : -f 1- wydrukuj pierwszą wyciętą kolumnę, używając :jako separatora
• 2>/dev/null- tailwyjście błędu ciszy, które występuje, jeśli $()wyrażenie zwróci puste
• grep -q- milcz grepi wróć natychmiast, jeśli zostanie znalezione dopasowanie, ponieważ interesuje nas tylko kod wyjścia

To też powinno działać ?!

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

$ARGVzawiera nazwę bieżącego pliku podczas czytania z file_list /swyszukiwań modyfikatorów w nowej linii.

Plik *.shjest ważny, aby zapobiec przeglądaniu katalogów. Oczywiście niektóre testy mogłyby temu zapobiec.

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

The

grep -n -m1 abc $f 

wyszukuje maksymalnie 1 pasujące i zwraca (-n) numer bielizny. Jeśli znaleziono dopasowanie (test -n ...), znajdź ostatnie dopasowanie efg (znajdź wszystko i weź ostatnie z tail -n 1).

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

jeszcze dalej.

Ponieważ wynik jest podobny 18:foofile.sh String alf="abc";, musimy odciąć „:” do końca linii.

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

Powinien zwrócić wynik dodatni, jeśli ostatnie dopasowanie 2. wyrażenia minęło pierwsze dopasowanie pierwszego.

Następnie zgłaszamy nazwę pliku echo $f.

Dlaczego nie coś prostego, takiego jak:

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

zwraca 0 lub dodatnią liczbę całkowitą.

egrep -o (Pokazuje tylko dopasowania, trick: wiele dopasowań w tym samym wierszu daje wynik wieloliniowy, tak jakby były w różnych wierszach)

• grep -A1 abc (wypisz abc i wiersz po nim)

• grep efg | wc -l (0-n liczba linii efg znalezionych po abc w tej samej lub kolejnych liniach, wynik może być użyty w „jeśli”)

• grep można zmienić na egrep itp., jeśli potrzebne jest dopasowanie wzorca

Jeśli masz jakieś oszacowanie odległości między dwoma ciągami „abc” i „efg”, którego szukasz, możesz użyć:

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

W ten sposób pierwszy grep zwróci linię z „abc” plus # num1 linii po niej i # num2 linii po niej, a drugi grep przesieje wszystkie te, aby uzyskać „efg”. Wtedy będziesz wiedział, w których plikach pojawiają się razem.

Z ugrep wydanym kilka miesięcy temu:

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

To narzędzie jest wysoce zoptymalizowane pod kątem szybkości. Jest także kompatybilny z GNU / BSD / PCRE-grep.

Pamiętaj, że powinniśmy używać leniwego powtarzania +?, chyba że chcesz dopasować wszystkie linie efgrazem do ostatniej efgw pliku.

To powinno działać:

cat FILE | egrep 'abc|efg'

Jeśli jest więcej niż jedno dopasowanie, możesz je odfiltrować za pomocą grep -v