linux - texto - ¿Cómo grep recursivamente?




grep subdirectorios (16)

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

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

find . | xargs grep "texthere" *

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

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


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

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.


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

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 )

[email protected]$ sync && echo 3 | sudo tee /proc/sys/vm/drop_caches
3
[email protected]$ time grep -r "hey ya" .

real    0m9.458s
user    0m0.368s
sys 0m3.788s
[email protected]:$ sync && echo 3 | sudo tee /proc/sys/vm/drop_caches
3
[email protected]$ time ack-grep "hey ya" .

real    0m6.296s
user    0m0.716s
sys 0m1.056s
[email protected]$ sync && echo 3 | sudo tee /proc/sys/vm/drop_caches
3
[email protected]$ time ag "hey ya" .

real    0m5.641s
user    0m0.356s
sys 0m3.444s
[email protected]$ time ag "hey ya" . #test without first clearing cache

real    0m0.154s
user    0m0.224s
sys 0m0.172s

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