¿Cómo encontrar patrones en varias líneas usando grep?

Quiero encontrar archivos que tengan "abc" Y "efg" en ese orden, y esas dos cadenas están en líneas diferentes en ese archivo. Por ejemplo: un archivo con contenido:

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

Debería coincidir.

Grep no es suficiente para esta operación.

pcregrep, que se encuentra en la mayoría de los sistemas Linux modernos, puede usarse como

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

donde -M, --multiline permitir que los patrones coincidan con más de una línea

También hay un pcre2grep más nuevo . Ambos son proporcionados por el proyecto PCRE .

pcre2grep está disponible para Mac OS X a través de puertos Mac como parte del puerto pcre2:

% sudo port install pcre2 

y vía Homebrew como:

% brew install pcre

o para pcre2

% brew install pcre2

pcre2grep también está disponible en Linux (Ubuntu 18.04+)

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

No estoy seguro de si es posible con grep, pero sed lo hace muy fácil:

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

Aquí hay una solución inspirada en esta respuesta :

• si 'abc' y 'efg' pueden estar en la misma línea:

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

• si 'abc' y 'efg' deben estar en diferentes líneas:

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

Parámetros:

• -zTrate la entrada como un conjunto de líneas, cada una terminada por un byte cero en lugar de una nueva línea. es decir, grep trata la entrada como una línea grande.

• -l imprimir el nombre de cada archivo de entrada desde el que normalmente se habría impreso la salida.

• (?s)active PCRE_DOTALL, lo que significa que '.' encuentra cualquier personaje o nueva línea.

sed debería ser suficiente como el póster LJ mencionado anteriormente,

en lugar de! d simplemente puede usar p para imprimir:

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

Confié mucho en pcregrep, pero con grep más nuevo no necesita instalar pcregrep para muchas de sus características. Solo usagrep -P .

En el ejemplo de la pregunta del OP, creo que las siguientes opciones funcionan bien, con la segunda mejor coincidencia de cómo entiendo la pregunta:

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

Copié el texto como / tmp / test1 y eliminé la 'g' y lo guardé como / tmp / test2. Aquí está el resultado que muestra que el primero muestra la cadena coincidente y el segundo muestra solo el nombre del archivo (típico -o es para mostrar coincidencia y típico -l es para mostrar solo el nombre del archivo). Tenga en cuenta que la 'z' es necesaria para multilínea y '(. | \ N)' significa que coincide con 'cualquier cosa que no sea nueva línea' o 'nueva línea', es decir, cualquier cosa:

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

Para determinar si su versión es lo suficientemente nueva, ejecute man grepy vea si algo similar a esto aparece cerca de la parte superior:

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

Eso es de GNU grep 2.10.

Esto se puede hacer fácilmente usando primero trpara reemplazar las nuevas líneas con algún otro carácter:

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

Aquí, estoy usando el carácter de alarma \a(ASCII 7) en lugar de una nueva línea. Esto casi nunca se encuentra en su texto, y greppuede coincidir con .o específicamente con \a.

awk one-liner:

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

Puede hacerlo muy fácilmente si puede usar Perl.

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

También puede hacerlo con una sola expresión regular, pero eso implica tomar todo el contenido del archivo en una sola cadena, lo que podría terminar ocupando demasiada memoria con archivos grandes. Para completar, aquí está ese método:

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

No sé cómo haría eso con grep, pero haría algo así con awk:

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

Sin embargo, debes tener cuidado de cómo lo haces. ¿Desea que la expresión regular coincida con la subcadena o la palabra completa? agregue \ w etiquetas según corresponda. Además, si bien esto se ajusta estrictamente a la forma en que mencionó el ejemplo, no funciona cuando abc aparece por segunda vez después de efg. Si desea manejar eso, agregue un if según corresponda en el / abc / case, etc.

Lamentablemente, no puedes. De los grepdocumentos:

grep busca en los ARCHIVOS de entrada con nombre (o en la entrada estándar si no se nombra ningún archivo, o si se da un solo guión menos (-) como nombre de archivo) en busca de líneas que contengan una coincidencia con el PATRÓN dado.

Si está dispuesto a usar contextos, esto podría lograrse escribiendo

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

Esto mostrará todo entre "abc" y "efg", siempre que estén dentro de 500 líneas entre sí.

Si necesita que ambas palabras estén cercanas entre sí, por ejemplo, no más de 3 líneas, puede hacer esto:

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

El mismo ejemplo pero solo filtrando archivos * .txt:

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

Y también puede reemplazar el grepcomando con el egrepcomando si también desea encontrar con expresiones regulares.

Lancé una alternativa grep hace unos días que admite esto directamente, ya sea a través de la coincidencia multilínea o usando condiciones; espero que sea útil para algunas personas que buscan aquí. Así es como se verían los comandos para el ejemplo:

Multilínea:

sift -lm 'abc.*efg' testfile

Condiciones:

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

También podría especificar que 'efg' debe seguir a 'abc' dentro de un cierto número de líneas:

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

Puede encontrar más información en sift-tool.org .

Si bien la opción sed es la más simple y fácil, la única frase de LJ no es la más portátil. Aquellos atrapados con una versión de C Shell deberán escapar de su explosión:

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

Esto desafortunadamente no funciona en 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

puede usar grep en caso de que no le guste la secuencia del patrón.

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

ejemplo

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

grep -lencontrará todos los archivos que coincidan con el primer patrón, y xargs buscará el segundo patrón. Espero que esto ayude.

Con buscador de plata :

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

similar a la respuesta del portador del anillo, pero con ag en su lugar. Las ventajas de velocidad del buscador de plata posiblemente podrían brillar aquí.

Utilicé esto para extraer una secuencia fasta de un archivo multi fasta usando la opción -P para grep:

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

• P para búsquedas basadas en perl
• z para hacer que una línea finalice en 0 bytes en lugar de una nueva línea char
• o simplemente capturar lo que coincide, ya que grep devuelve la línea completa (que en este caso desde que lo hizo -z es todo el archivo).

El núcleo de la expresión regular es el [^>]que se traduce como "no mayor que el símbolo"

Como alternativa a la respuesta de Balu Mohan, es posible hacer cumplir la orden de los patrones usando solamente grep, heady 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

Sin embargo, este no es muy bonito. Formateado de forma más legible:

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

Esto imprimirá los nombres de todos los archivos donde "pattern2"aparece después "pattern1", o donde ambos aparecen en la misma línea :

$ 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

Explicación

• tail -n +i - imprime todas las líneas después de i th, inclusive
• grep -n - anteponer líneas coincidentes con sus números de línea
• head -n1 - imprime solo la primera fila
• cut -d : -f 1 - imprima la primera columna cortada usando : como delimitador
• 2>/dev/null- tailsalida de error de silencio que ocurre si el$() expresión vuelve vacía
• grep -q- Silencio grepy regreso inmediatamente si se encuentra una coincidencia, ya que solo estamos interesados ​​en el código de salida

¿Esto también debería funcionar?

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

$ARGVcontiene el nombre del archivo actual cuando se leen file_list /sbúsquedas de modificadores en la nueva línea.

El patrón de archivos *.shes importante para evitar que los directorios sean inspeccionados. Por supuesto, algunas pruebas también podrían evitarlo.

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

los

grep -n -m1 abc $f 

busca un máximo de 1 coincidencia y devuelve (-n) el número de lino. Si se encontró una coincidencia (prueba -n ...) encuentre la última coincidencia de efg (encuentre todo y tome la última con la cola -n 1).

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

De lo contrario continuar.

Como el resultado es algo así 18:foofile.sh String alf="abc";, necesitamos cortar ":" hasta el final de la línea.

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

Debería devolver un resultado positivo si la última coincidencia de la segunda expresión ha pasado la primera coincidencia de la primera.

Luego informamos el nombre del archivo echo $f.

¿Por qué no algo tan simple como:

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

devuelve 0 o un entero positivo.

egrep -o (solo muestra coincidencias, truco: varias coincidencias en la misma línea producen una salida de varias líneas como si estuvieran en líneas diferentes)

• grep -A1 abc (imprima abc y la línea que sigue)

• grep efg | wc -l (0-n recuento de líneas efg encontradas después de abc en la misma línea o en las siguientes, el resultado puede usarse en un 'si')

• grep se puede cambiar a egrep, etc. si se necesita la coincidencia de patrones

Si tiene alguna estimación acerca de la distancia entre las 2 cadenas 'abc' y 'efg' que está buscando, puede usar:

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

De esa manera, el primer grep devolverá la línea con el 'abc' más # num1 líneas después de él, y # num2 líneas después, y el segundo grep tamizará todos esos para obtener el 'efg'. Entonces sabrás en qué archivos aparecen juntos.

Con ugrep lanzado hace unos meses:

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

Esta herramienta está altamente optimizada para la velocidad. También es compatible con GNU / BSD / PCRE-grep.

Tenga en cuenta que deberíamos usar una repetición perezosa +?, a menos que desee hacer coincidir todas las líneas efgjuntas hasta la última efgen el archivo.

Esto debería funcionar:

cat FILE | egrep 'abc|efg'

Si hay más de una coincidencia, puede filtrar usando grep -v