subdirectorios - grep linux sintaxis

¿Cómo grep recursivamente? (24)

¿Cómo grep recursivamente todos los directorios y subdirectorios?

find . | xargs grep "texthere" *

globbing `**`

El uso de grep -r funciona, pero puede ser excesivo, especialmente en carpetas grandes.

Para un uso más práctico, aquí está la sintaxis que usa la sintaxis de globbing ( ** ):

grep "texthere" **/*.txt

que codifica solo archivos específicos con patrón seleccionado patrón. Funciona para shells soportados como Bash +4 o zsh .

Para activar esta característica, ejecute: shopt -s globstar .

Ver también: ¿Cómo encuentro todos los archivos que contienen texto específico en Linux?

`git grep`

Para proyectos bajo el control de versiones de Git, use:

git grep "pattern"

que es mucho más rápido.

`ripgrep`

Para proyectos más grandes, la herramienta de grepping más rápida es ripgrep que recurre los archivos de forma recursiva por defecto:

rg "pattern" .

Está construido sobre el motor de expresiones regulares de Rust, que utiliza autómatas finitos, SIMD y optimizaciones literales agresivas para que la búsqueda sea muy rápida. Compruebe el análisis detallado aquí .

A continuación se muestra el comando para buscar una String recursiva en entornos Unix y Linux .

para comando UNIX es:

find . -name "string to be searched" -exec grep "text" "{}" /;

para comando de Linux es:

grep -r "string to be searched" .

Ahora siempre uso (incluso en Windows con GoW - Gnu en Windows ):

grep --include="*.xxx" -nRHI "my Text to grep" *

Eso incluye las siguientes opciones:

--include=PATTERN

Recurse en directorios solo buscando archivos que coincidan con PATTERN .

-n, --line-number

Prefije cada línea de salida con el número de línea dentro de su archivo de entrada.

-R, -r, --recursive

Lee todos los archivos debajo de cada directorio, recursivamente; esto es equivalente a la opción -d recurse .

-H, --with-filename

Imprima el nombre del archivo para cada coincidencia.

-I

Procese un archivo binario como si no contuviera datos coincidentes;
esto es equivalente a la --binary-files=without-match .

Y puedo agregar '' i '' ( -nRHIi ), si quiero resultados que no -nRHIi mayúsculas y minúsculas.

Puedo conseguir:

/home/vonc/gitpoc/passenger/gitlist/github #grep --include="*.php" -nRHI "hidden" * src/GitList/Application.php:43: ''git.hidden'' => $config->get(''git'', ''hidden'') ? $config->get(''git'', ''hidden'') : array(), src/GitList/Provider/GitServiceProvider.php:21: $options[''hidden''] = $app[''git.hidden'']; tests/InterfaceTest.php:32: $options[''hidden''] = array(self::$tmpdir . ''/hiddenrepo''); vendor/klaussilveira/gitter/lib/Gitter/Client.php:20: protected $hidden; vendor/klaussilveira/gitter/lib/Gitter/Client.php:170: * Get hidden repository list vendor/klaussilveira/gitter/lib/Gitter/Client.php:176: return $this->hidden; ...

Aquí hay una función recursiva (probada ligeramente con bash y sh) que atraviesa todas las subcarpetas de una carpeta determinada ($ 1) y usa búsquedas grep para una cadena dada ($ 3) en archivos dados ($ 2):

$ cat script.sh #!/bin/sh cd "$1" loop () { for i in * do if [ -d "$i" ] then # echo entering "$i" cd "$i" loop "$1" "$2" fi done if [ -f "$1" ] then grep -l "$2" "$PWD/$1" fi cd .. } loop "$2" "$3"

Ejecutándolo y un ejemplo de salida:

$ sh script start_folder filename search_string /home/james/start_folder/dir2/filename

En 2018, desea utilizar ripgrep o the-silver-searcher porque son mucho más rápidos que las alternativas.

Aquí hay un directorio con 336 subdirectorios de primer nivel:

% find . -maxdepth 1 -type d | wc -l 336 % time rg -w aggs -g ''*.py'' ... rg -w aggs -g ''*.py'' 1.24s user 2.23s system 283% cpu 1.222 total % time ag -w aggs -G ''.*py$'' ... ag -w aggs -G ''.*py$'' 2.71s user 1.55s system 116% cpu 3.651 total % time find ./ -type f -name ''*.py'' | xargs grep -w aggs ... find ./ -type f -name ''*.py'' 1.34s user 5.68s system 32% cpu 21.329 total xargs grep -w aggs 6.65s user 0.49s system 32% cpu 22.164 total

En OSX, esto instala ripgrep : brew install ripgrep . Esto instala silver-searcher brew install the_silver_searcher : brew install the_silver_searcher .

En los sistemas POSIX, no encuentra el parámetro -r para grep y su grep -rn "stuff" . no se ejecutará, pero si usa el comando find lo hará:

find . -type f -exec grep -n "stuff" {} /; -print

Acordado por Solaris y HP-UX .

En mi servidor IBM AIX (versión de sistema operativo: AIX 5.2), use:

find ./ -type f -print -exec grep -n -i "stringYouWannaFind" {} /;

esto imprimirá la ruta / nombre del archivo y el número de línea relativo en el archivo como:

./inc/xxxx_x.h

2865: / ** Descripción: stringYouWannaFind * /

De todos modos, funciona para mí:)

Este es el que funcionó para mi caso en mi máquina actual (git bash en Windows 7):

find ./ -type f -iname "*.cs" -print0 | xargs -0 grep "content pattern"

Siempre me olvido de -print0 y -0 para caminos con espacios.

EDITAR: Mi herramienta preferida es ahora ripgrep: https://github.com/BurntSushi/ripgrep/releases . Es realmente rápido y tiene mejores valores predeterminados (recursivo por defecto). El mismo ejemplo que mi respuesta original, pero usando ripgrep: rg -g "*.cs" "content pattern"

Esto debería funcionar:

grep -R "texthere" *

O instale ACK, si quiere una forma mucho más rápida y está haciendo esto mucho.

Para buscar el nombre de los files con path recursiva que contiene la string particular, use el comando siguiente para UNIX :

find . | xargs grep "searched-string"

para Linux :

grep -r "searched-string" .

encontrar un archivo en el servidor UNIX

find . -type f -name file_name

encontrar un archivo en el servidor LINUX

find . -name file_name

Para una lista de banderas disponibles:

grep --help

Devuelve todas las coincidencias para la expresión regular de texto en el directorio actual, con el número de línea correspondiente:

grep -rn "texthere" .

Devuelve todas las coincidencias para texthere , comenzando en el directorio raíz, con el número de línea correspondiente y el caso de ignorar:

grep -rni "texthere" /

banderas utilizadas aquí:

-r recursivo
-n número de línea de impresión con salida
-i ignoro el caso

Si conoce la extensión o el patrón del archivo que desea, otro método es usar la opción --include :

grep -r --include "*.txt" texthere .

También puede mencionar archivos para excluir con --exclude .

Ag

Si busca frecuentemente en el código, github.com/ggreer/the_silver_searcher es una alternativa mucho más rápida a grep, que está personalizada para buscar código. Por ejemplo, es recursivo de manera predeterminada e ignora automáticamente los archivos y directorios enumerados en .gitignore , por lo que no tiene que seguir pasando las mismas opciones de exclusión incómodas a grep o find.

Si está buscando un contenido específico en todos los archivos de una estructura de directorios, puede usar find ya que es más claro lo que está haciendo:

find -type f -exec grep -l "texthere" {} +

Tenga en cuenta que -l (downcase of L) muestra el nombre del archivo que contiene el texto. Elimínelo si desea imprimir la coincidencia. O use -H para obtener el archivo junto con la coincidencia. Todas juntas, otras alternativas son:

find -type f -exec grep -Hn "texthere" {} +

Donde -n imprime el número de línea.

Si solo desea seguir directorios reales, y no enlaces simbólicos,

grep -r "thingToBeFound" directory

Si desea seguir los enlaces simbólicos, así como los directorios reales (tenga cuidado de la recursión infinita),

grep -R "thing to be found" directory

Ya que estás tratando de grep recursivamente, las siguientes opciones también pueden ser útiles para ti:

-H: outputs the filename with the line -n: outputs the line number in the file

Entonces, si desea encontrar todos los archivos que contienen Darth Vader en el directorio actual o en cualquier subdirectorio y capturar el nombre del archivo y el número de línea, pero no desea que la recursión siga los enlaces simbólicos, el comando sería

grep -rnH "Darth Vader" .

Si quieres encontrar todas las menciones de la palabra cat en el directorio.

/home/adam/Desktop/TomAndJerry

y estas actualmente en el directorio

/home/adam/Desktop/WorldDominationPlot

y desea capturar el nombre del archivo, pero no el número de línea de ninguna instancia de la cadena "cats", y desea que la recursión siga los enlaces simbólicos si los encuentra, puede ejecutar cualquiera de los siguientes

grep -RH "cats" ../TomAndJerry #relative directory grep -RH "cats" /home/adam/Desktop/TomAndJerry #absolute directory

Fuente:

ejecutando "grep - help"

Una breve introducción a los enlaces simbólicos, para cualquiera que lea esta respuesta y se confunda con mi referencia a ellos: https://www.nixtutor.com/freebsd/understanding-symbolic-links/

Solo por diversión, una búsqueda rápida y sucia de archivos * .txt si la respuesta de @christangrant es demasiado para escribir :-)

grep -r texthere .|grep .txt

Supongo que esto es lo que estás tratando de escribir.

grep myText $(find .)

y esto puede ser algo más útil si desea encontrar los archivos afectados por grep

grep myText $(find .) | cut -d : -f 1 | sort | uniq

También:

find ./ -type f -print0 | xargs -0 grep "foo"

pero grep -r es una mejor respuesta.

Tenga en cuenta que find . -type f | xargs grep whatever find . -type f | xargs grep whatever find . -type f | xargs grep whatever tipo de solución se encontrará con errores de "Lista de discusión a larga" cuando hay demasiados archivos que coinciden con encontrar.

La mejor apuesta es grep -r pero si no está disponible, use find . -type f -exec grep -H whatever {} /; find . -type f -exec grep -H whatever {} /; en lugar.

ag es mi forma favorita de hacer esto ahora github.com/ggreer/the_silver_searcher . Es básicamente lo mismo que ACK pero con algunas optimizaciones más.

Aquí hay un breve punto de referencia. Limpio la memoria caché antes de cada prueba (consulte https://askubuntu.com/questions/155768/how-do-i-clean-or-disable-the-memory-cache )

ryan@3G08$ sync && echo 3 | sudo tee /proc/sys/vm/drop_caches 3 ryan@3G08$ time grep -r "hey ya" . real 0m9.458s user 0m0.368s sys 0m3.788s ryan@3G08:$ sync && echo 3 | sudo tee /proc/sys/vm/drop_caches 3 ryan@3G08$ time ack-grep "hey ya" . real 0m6.296s user 0m0.716s sys 0m1.056s ryan@3G08$ sync && echo 3 | sudo tee /proc/sys/vm/drop_caches 3 ryan@3G08$ time ag "hey ya" . real 0m5.641s user 0m0.356s sys 0m3.444s ryan@3G08$ time ag "hey ya" . #test without first clearing cache real 0m0.154s user 0m0.224s sys 0m0.172s

solo los nombres de archivos pueden ser útiles también

grep -r -l "foo" .

grep -r "texthere" . (período de aviso al final)

(^ crédito: https://.com/a/1987928/1438029 )

Aclaración:

grep -r "texthere" / (recursivamente grep todos los directorios y subdirectorios)

grep -r "texthere" . (recursivamente grep estos directorios y subdirectorios)

grep recursivo

grep [options] PATTERN [FILE...]

[opciones]
-R, -r, --recursive

Lee todos los archivos debajo de cada directorio, recursivamente.
Esto es equivalente a la opción -d recurse o --directories=recurse .
http://linuxcommand.org/man_pages/grep1.html

ayuda grep

$ grep --help

$ grep --help |grep recursive -r, --recursive like --directories=recurse -R, --dereference-recursive

Alternativas

ack ( ack )

ag ( github.com/ggreer/the_silver_searcher )

The syntax is: cd /path/to/dir grep -r <"serch_word name"> .

grep -r "texthere" .

El primer parámetro representa la expresión regular para buscar, mientras que el segundo representa el directorio en el que se debe buscar. En este caso . significa el directorio actual.

Nota: Esto funciona para GNU grep, y en algunas plataformas como Solaris debe usar GNU grep específicamente en lugar de la implementación heredada. Para Solaris este es el comando ggrep .