subdirectorios - grep linux sintaxis

¿Cómo grep recursivamente?

Question

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

find . | xargs grep "texthere" *

Answer 1

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

Answer 2

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

Answer 3

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

Answer 4

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

Answer 5

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 .

Answer 6

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 .

Answer 7

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í:)

Answer 8

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"

Answer 9

Esto debería funcionar:

grep -R "texthere" *

Answer 10

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

Answer 11

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

Answer 12

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

Answer 13

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.

Answer 14

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.

Answer 15

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/

Answer 16

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

Answer 17

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

Answer 18

También:

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

pero grep -r es una mejor respuesta.

Answer 19

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.

Answer 20

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

Answer 21

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

grep -r -l "foo" .

Answer 22

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 )

Answer 23

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

Answer 24

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 .