¿Cómo encuentro archivos que no contienen un patrón de cadena dado?

¿Cómo encuentro los archivos en el directorio actual que no contienen la palabra foo(usando grep)?

Si su grep tiene la opción -L(o --files-without-match):

$ grep -L "foo" *

Echa un vistazo a ack. Hace la .svnexclusión automáticamente, le da expresiones regulares de Perl y es una simple descarga de un solo programa de Perl.

El equivalente de lo que está buscando debe ser, en ack:

ack -L foo

Puedes hacerlo solo con grep (sin encontrar).

grep -riL "foo" .

Esta es la explicación de los parámetros utilizados en grep

     -L, --files-without-match
             each file processed.
     -R, -r, --recursive
             Recursively search subdirectories listed.

     -i, --ignore-case
             Perform case insensitive matching.

Si usa l(en minúsculas) obtendrá lo contrario (archivos con coincidencias)

     -l, --files-with-matches
             Only the names of files containing selected lines are written

El siguiente comando me da todos los archivos que no contienen el patrón foo:

find .  -not  -ipath '.*svn*' -exec  grep  -H -E -o -c  "foo"  {} \; | grep 0

El siguiente comando excluye la necesidad de encontrar para filtrar las svncarpetas mediante el uso de un segundo grep.

grep -rL "foo" ./* | grep -v "\.svn"

Realmente necesitarás:

find .  -not  -ipath '.*svn*' -exec  grep  -H -E -o -c  "foo"  {} \; | grep :0\$

Tuve buena suerte con

grep -H -E -o -c "foo" */*/*.ext | grep ext:0

Mis intentos con grep -vsolo me dieron todas las líneas sin "foo".

Problema

Necesito refactorizar un proyecto grande que usa .phtmlarchivos para escribir HTML usando código PHP en línea. Quiero usar plantillas de bigote en su lugar. Quiero encontrar cualquier .phtmlgiles que no contenga la cadena, new Mustacheya que aún deben reescribirse.

Solución

find . -iname '*.phtml' -exec grep -H -E -o -c 'new Mustache' {} \; | grep :0$ | sed 's/..$//'

Explicación

Antes de las tuberías:

Encontrar

find . Encuentra archivos recursivamente, comenzando en este directorio

-iname '*.phtml'El nombre del archivo debe contener .phtml( iesto hace que no distinga entre mayúsculas y minúsculas)

-exec 'grep -H -E -o -c 'new Mustache' {}'Ejecute el grepcomando en cada una de las rutas coincidentes

Grep

-H Siempre imprima encabezados de nombre de archivo con líneas de salida.

-E Interprete el patrón como una expresión regular extendida (es decir, forzar a grep a comportarse como egrep).

-o Imprime solo la parte coincidente de las líneas.

-c Solo un recuento de líneas seleccionadas se escribe en la salida estándar.

Esto me dará una lista de todas las rutas de archivos que terminan en .phtml, con un recuento de la cantidad de veces que la cadena new Mustacheocurre en cada una de ellas.

$> find . -iname '*.phtml$' -exec 'grep -H -E -o -c 'new Mustache' {}'\;

./app/MyApp/Customer/View/Account/quickcodemanagestore.phtml:0
./app/MyApp/Customer/View/Account/studio.phtml:0
./app/MyApp/Customer/View/Account/orders.phtml:1
./app/MyApp/Customer/View/Account/banking.phtml:1
./app/MyApp/Customer/View/Account/applycomplete.phtml:1
./app/MyApp/Customer/View/Account/catalogue.phtml:1
./app/MyApp/Customer/View/Account/classadd.phtml:0
./app/MyApp/Customer/View/Account/orders-trade.phtml:0

La primera tubería grep :0$filtra esta lista para incluir solo líneas que terminan en :0:

$> find . -iname '*.phtml' -exec grep -H -E -o -c 'new Mustache' {} \; | grep :0$

./app/MyApp/Customer/View/Account/quickcodemanagestore.phtml:0
./app/MyApp/Customer/View/Account/studio.phtml:0
./app/MyApp/Customer/View/Account/classadd.phtml:0
./app/MyApp/Customer/View/Account/orders-trade.phtml:0

La segunda tubería sed 's/..$//'elimina los dos caracteres finales de cada línea, dejando solo las rutas de archivo.

$> find . -iname '*.phtml' -exec grep -H -E -o -c 'new Mustache' {} \; | grep :0$ | sed 's/..$//'

./app/MyApp/Customer/View/Account/quickcodemanagestore.phtml
./app/MyApp/Customer/View/Account/studio.phtml
./app/MyApp/Customer/View/Account/classadd.phtml
./app/MyApp/Customer/View/Account/orders-trade.phtml

Si está utilizando git, esto busca todos los archivos rastreados:

git grep -L "foo"

y puede buscar en un subconjunto de archivos rastreados si tiene activado ** globbing del subdirectorio ( shopt -s globstaren .bashrc, vea esto ):

git grep -L "foo" -- **/*.cpp

Mi grep no tiene ninguna opción -L. Encuentro la solución para lograr esto.

Las ideas son:

1. para volcar todo el nombre del archivo que contiene la cadena merecida en un txt1.txt.
2. volcar todo el nombre del archivo en el directorio a un txt2.txt.

3. marque la diferencia entre el archivo de volcado 2 con el comando diff.

   grep 'foo' *.log | cut -c1-14 | uniq > txt1.txt
   grep * *.log | cut -c1-14 | uniq > txt2.txt
   diff txt1.txt txt2.txt | grep ">"
   

find *20161109* -mtime -2|grep -vwE "(TRIGGER)"

Puede especificar el filtro en "buscar" y la cadena de exclusión en "grep -vwE". Use mtime en find si necesita filtrar también en el tiempo modificado.

Informe de error abierto

Como comentó @tukan, hay un informe de error abierto para Ag con respecto a la bandera -L/ --files-without-matches:

• ggreer / the_silver_searcher: # 238 - --files-without-matchesno funciona correctamente

Como hay poco progreso en el informe de error, no se debe confiar en la -Lopción mencionada a continuación , siempre y cuando el error no se haya resuelto. Utilice diferentes enfoques presentados en este hilo en su lugar. Citando un comentario para el informe de error [énfasis mío]:

¿Alguna actualización sobre esto? -Lignora completamente las coincidencias en la primera línea del archivo. Parece que si esto no se va a solucionar pronto, la bandera debería eliminarse por completo, ya que efectivamente no funciona como se anuncia .

The Silver Searcher - Ag (función prevista - ver informe de error)

Como una alternativa poderosa a grep, podría usar The Silver Searcher - Ag :

Una herramienta de búsqueda de código similar a ack, con un enfoque en la velocidad.

Mirando man ag, encontramos la opción -Lu --files-without-matches:

...

OPTIONS
    ...

    -L --files-without-matches
           Only print the names of files that don´t contain matches.

Es decir, para buscar de forma recursiva archivos que no coinciden foo, desde el directorio actual:

ag -L foo

Para buscar solo en el directorio actual archivos que no coincidan foo, simplemente especifique --depth=0la recursividad:

ag -L foo --depth 0

Otra alternativa cuando grep no tiene la opción -L (IBM AIX por ejemplo), con nada más que grep y el shell:

for file in * ; do grep -q 'my_pattern' $file || echo $file ; done

grep -irnw "filepath" -ve "pattern"

o

grep -ve "pattern" < file

el comando anterior nos dará el resultado cuando -v encuentre el inverso del patrón que se está buscando

El siguiente comando podría ayudarlo a filtrar las líneas que incluyen la subcadena "foo".

cat file | grep -v "foo"