Cómo utilizar el comando "grep" para buscar texto, incluidos subdirectorios

Quiero encontrar todos los archivos que contienen una cadena de texto específica. El grepcomando funciona, pero no sé cómo usarlo para cada directorio (solo puedo hacerlo para mi directorio actual). Intenté leer man grep, pero no me sirvió de nada.

Sería mejor usar

grep -rl "string" /path

dónde

• -r(o --recursive) la opción se usa para recorrer también todos los subdirectorios de /path, mientras que
• -l(o --files-with-matches) la opción se usa para imprimir solo nombres de archivos de archivos coincidentes, y no las líneas coincidentes (esto también podría mejorar la velocidad, dado que grepdeja de leer un archivo en la primera coincidencia con esta opción).

Si está buscando líneas que coincidan en los archivos, mi comando favorito es:

grep -Hrn 'search term' path/to/files

• -H hace que se imprima el nombre del archivo (implícito cuando se buscan varios archivos)
• -r hace una búsqueda recursiva
• -n hace que se imprima el número de línea

path/to/filespuede ser .buscar en el directorio actual

Otras opciones que encuentro muy útiles:

• -Iignorar archivos binarios (complemento: -atratar todos los archivos como texto)
• -Ftratar search termcomo un literal, no como una expresión regular
• -i hacer una búsqueda entre mayúsculas y minúsculas

• --color=alwayspara forzar los colores incluso al pasar a través less. Para crear lesscolores de soporte, debe usar la -ropción:

  grep -Hrn search . | less -r
  

• --exclude-dir=dirútil para excluir directorios como .svny .git.

Creo que puedes usar algo como esto:

find /path -type f -exec grep -l "string" {} \;

Explicación de comentarios

findes un comando que le permite encontrar archivos y otros objetos como directorios y enlaces en subdirectorios de una ruta determinada. Si no especifica una máscara que los nombres de archivo deben cumplir, enumera todos los objetos de directorio.

• -type f especifica que solo debe procesar archivos, no directorios, etc.
• -exec grepespecifica que para cada archivo encontrado, debe ejecutar el comando grep, pasando su nombre de archivo como argumento, reemplazándolo {}por el nombre de archivo

Mi comando predeterminado es

grep -Rin string *

Yo uso un capitol 'R' porque lo lsusa para recursivo. Dado que grep acepta ambos, no hay razón para no usarlo.

EDITAR: por HVNSweeting, aparentemente -Rseguirá enlaces simbólicos donde -rno lo hará.

Si estás dispuesto a probar algo nuevo, dale ackuna oportunidad. El comando para buscar recursivamente el directorio actual stringes:

ack string

La instalación es bastante simple:

curl http://betterthangrep.com/ack-standalone > ~/bin/ack && chmod 0755 !#:3

(Siempre que ya tenga el directorio ~/biny esté preferiblemente en su PATH.)

El comando rgrep está dedicado para tal necesidad

Si no está disponible, puede obtenerlo así

mkdir -p ~/bin
cd ~/bin
wget http://sdjf.esmartdesign.com/files/rgrep
chmod +x rgrep

Puede establecer directamente en sus opciones grep predeterminadas como se describe anteriormente.

Yo personalmente uso

[[  ${#args} -lt 5 && "${args//[[:space:]]/}" == "-i" ]] && args="-Hin"
args="${args:--Hns} --color=auto"

tema relacionado: cómo usar siempre rgrep con color

Actualización 2:

Esta línea de comandos utiliza findy grepsoluciona el problema:

$ find path_to_search_in -type f -exec grep -in searchString {} 2> /dev/null +

--color=<always or auto> para salida en color:

$ find path_to_search_in -type f \
            -exec grep --color=always -in searchString {} 2>/dev/null +

Ejemplo:

$ find /tmp/test/ -type f -exec grep --color=auto -in "Search string" {} 2>/dev/null +

Un ejemplo se ejecuta en la siguiente instantánea:

Actualización 1:

Puedes probar el siguiente código; como una función en su .bashrco .bash_aliaseso en un script:

wherein () 
{ 
    for i in $(find "$1" -type f 2> /dev/null);
    do
        if grep --color=auto -i "$2" "$i" 2> /dev/null; then
            echo -e "\033[0;32mFound in: $i \033[0m\n";
        fi;
    done
}

Uso: wherein /path/to/search/in/ searchkeyword

ejemplo:

$ wherein ~/Documents/ "hello world"

(Nota: como se sugiere en los comentarios a continuación por @enzotib, esto no funciona con archivos / directorios que incluyen espacios en sus nombres).

Publicación original

Para buscar la cadena y generar solo esa línea con la cadena de búsqueda:

$ for i in $(find /path/of/target/directory -type f); do \
    grep -i "the string to look for" "$i"; done

p.ej:

$ for i in $(find /usr/share/applications -type f); \
    do grep -i "web browser" "$i"; done

Para mostrar el nombre de archivo que contiene la cadena de búsqueda:

$ for i in $(find /path/of/target/directory -type f); do \
    if grep -i "the string to look for" "$i" > /dev/null; then echo "$i"; fi; done;

p.ej:

$ for i in $(find /usr/share/applications -type f); \
    do if grep -i "web browser" "$i" > /dev/null; then echo "$i"; \
    fi; done;

grep( GNU o BSD )

Puede usar la grepherramienta para buscar de forma recursiva la carpeta actual con -rparámetros, como:

grep -r "pattern" .

^{Nota: -r- Recursivamente busca subdirectorios.}

Para buscar dentro de archivos específicos, puede usar una sintaxis global como:

grep "class foo" **/*.c

^{Nota: Al usar la opción global ( **), escanea todos los archivos de forma recursiva con una extensión o patrón específico. Para habilitar esta sintaxis, ejecute: shopt -s globstar. También puede usarlo **/*.*para todos los archivos (excepto los ocultos y sin extensión) o cualquier otro patrón.}

Si tiene el error de que su argumento es demasiado largo, considere reducir su búsqueda, o use una findsintaxis en su lugar como:

find . -name "*.php" -execdir grep -nH --color=auto foo {} ';'

Alternativamente uso ripgrep.

ripgrep

Si está trabajando en proyectos más grandes o archivos grandes, debe usarlos ripgrep, como:

rg "pattern" .

^{Consulte los documentos, los pasos de instalación o el código fuente en la página del proyecto GitHub .}

Es mucho más rápido que cualquier otra herramienta como GNU / BSD grep , ucg, ag, sift, ack, pto similares, ya que se construye en la parte superior del motor de expresiones regulares de Rust que utiliza autómatas finitos, SIMD y optimizaciones literales agresivas para que la búsqueda sea muy rápido.

Es compatible con los patrones de ignorar especificados en los .gitignorearchivos, por lo que una sola ruta de archivo se puede comparar con múltiples patrones globales simultáneamente.

Puede usar los parámetros comunes como:

• -i - Búsqueda insensible.
• -I - Ignorar los archivos binarios.
• -w - Buscar las palabras completas (en oposición a la coincidencia parcial de palabras).
• -n - Muestra la línea de tu partido.
• -C/ --context(p -C5. ej. ): aumenta el contexto para que vea el código circundante.
• --color=auto - Marcar el texto correspondiente.
• -H - Muestra el nombre del archivo donde se encuentra el texto.
• -c- Muestra el recuento de líneas coincidentes. Se puede combinar con -H.

Hago esto usando xargs, un comando muy subestimado

find ./ -type f -print0 | xargs -0 grep 'string_you_are_looking_for'

find ./ le brinda una lista recursiva de todos los archivos en una carpeta actual y luego la canaliza a xargs que ejecuta el comando grep en cada uno de esos archivos

Sé que hay muchas respuestas aquí, pero aquí hay una alternativa si desea agregar otras restricciones al buscar los archivos:

find . -type f -exec grep --quiet string_to_look_for {} ';' -print

Esto funciona porque grepdevolverá 0 si encuentra un resultado, 1 de lo contrario. Por ejemplo, puede encontrar archivos de 1 MB de tamaño y que contengan algo:

find . -type f -exec grep --quiet string_to_look_for {} ';' -size 1M -print

Para múltiples requisitos, probablemente desee utilizar el indicador de optimizador -Oque existe en GNU grep.

Un script (buscar en el código) para buscar en C, código CPP:

#!/bin/sh

find . \( -iname "*.c" -o -iname "*.cpp" -o -iname "*.h" \) -type f -print0 | xargs -0 grep --color -n "$1"

Utilizar:

find-in-code "search string"