it-swarm-es.tech

¿Cómo encuentro todos los archivos que contienen texto específico en Linux?

Estoy tratando de encontrar una manera de escanear todo mi sistema Linux en busca de todos los archivos que contienen una cadena de texto específica. Solo para aclarar, estoy buscando texto dentro del archivo, no en el nombre del archivo.

Cuando estaba buscando cómo hacer esto, encontré esta solución dos veces:

find / -type f -exec grep -H 'text-to-find-here' {} \;

Sin embargo, no funciona. Parece mostrar todos los archivos en el sistema.

¿Está esto cerca de la forma correcta de hacerlo? Si no, ¿cómo debería? Esta capacidad de encontrar cadenas de texto en archivos sería extraordinariamente útil para algunos proyectos de programación que estoy haciendo.

4457
Nathan

Haz lo siguiente:

grep -rnw '/path/to/somewhere/' -e 'pattern'
  • -r o -R es recursivo,
  • -n es el número de línea, y
  • -w significa coincidir con toda la Palabra.
  • -l (L minúscula) se puede agregar para simplemente dar el nombre de archivo de los archivos coincidentes.

Junto con estos, los indicadores --exclude, --include, --exclude-dir podrían usarse para una búsqueda eficiente:

  • Esto solo buscará a través de aquellos archivos que tienen extensiones .c o .h:

    grep --include=\*.{c,h} -rnw '/path/to/somewhere/' -e "pattern"
    
  • Esto excluirá la búsqueda de todos los archivos que terminen con la extensión .o:

    grep --exclude=*.o -rnw '/path/to/somewhere/' -e "pattern"
    
  • Para directorios, es posible excluir un directorio (s) en particular a través del parámetro --exclude-dir. Por ejemplo, esto excluirá los dirs dir1 /, dir2/y todos ellos que coincidan con * .dst /:

    grep --exclude-dir={dir1,dir2,*.dst} -rnw '/path/to/somewhere/' -e "pattern"
    

Esto funciona muy bien para mí, para lograr casi el mismo propósito que el tuyo.

Para más opciones verifique man grep.

8076
rakib_

Puedes usar grep -ilR:

grep -Ril "text-to-find-here" /
  • i significa caso de ignorar (opcional en su caso).
  • R significa recursiva.
  • l significa "mostrar el nombre del archivo, no el resultado en sí mismo".
  • / significa comenzar en la raíz de su máquina.
1279
fedorqui

Puedes usar ack . Es como grep para el código fuente. Puede escanear todo su sistema de archivos con él.

Solo haz:

ack 'text-to-find-here'

En su directorio raíz.

También puede usar expresiones regulares , especificar el tipo de archivo, etc.


ACTUALIZACIÓN

Acabo de descubrir The Silver Searcher , que es como un ack pero 3-5 veces más rápido que él e incluso ignora los patrones de un archivo .gitignore.

283
EarlOfEgo

Puedes usar:

grep -r "string to be searched"  /path/to/dir

La r significa recursiva y, por lo tanto, buscará en la ruta especificada y también en sus subdirectorios. Esto le indicará el nombre del archivo y también imprimirá la línea en el archivo donde aparece la cadena.

O un comando similar al que está intentando (ejemplo:) para buscar en todos los archivos javascript (* .js):

find . -name '*.js' -exec grep -i 'string to search for' {} \; -print

Esto imprimirá las líneas en los archivos donde aparece el texto, pero no imprime el nombre del archivo.

Además de este comando, podemos escribir esto también: grep -rn "Cadena para buscar"/ruta/a/directorio/o/archivo -r: búsqueda recursiva n: el número de línea se mostrará para coincidencias

156
learner_19

Puedes usar esto:

grep -inr "Text" folder/to/be/searched/
98
A R

Lista de nombres de archivos que contienen un texto dado

En primer lugar, creo que ha usado -H en lugar de -l. También puedes intentar agregar el texto dentro de las comillas seguido de {} \.

find / -type f -exec grep -l "text-to-find-here" {} \; 

Ejemplo

Digamos que está buscando archivos que contengan el texto específico "Licencia de Apache" dentro de su directorio. Mostrará resultados similares a los siguientes (la salida será diferente según el contenido de su directorio).

bash-4.1$ find . -type f -exec grep -l "Apache License" {} \; 
./net/Java/jvnet-parent/5/jvnet-parent-5.pom
./commons-cli/commons-cli/1.3.1/commons-cli-1.3.1.pom
./io/swagger/swagger-project/1.5.10/swagger-project-1.5.10.pom
./io/netty/netty-transport/4.1.7.Final/netty-transport-4.1.7.Final.pom
./commons-codec/commons-codec/1.9/commons-codec-1.9.pom
./commons-io/commons-io/2.4/commons-io-2.4.pom
bash-4.1$ 

Eliminar la sensibilidad del caso

Incluso si no usa el caso como "texto" vs "TEXTO", puede usar el interruptor -i para ignorar el caso. Puedes leer más detalles aquí .

Espero que esto te ayude.

59
lkamal

Si su grep no admite la búsqueda recursiva, puede combinar find con xargs:

find / -type f | xargs grep 'text-to-find-here'

Encuentro esto más fácil de recordar que el formato para find -exec.

Esto generará el nombre del archivo y el contenido de la línea coincidente, por ejemplo,.

/home/rob/file:text-to-find-here

Indicadores opcionales que puede agregar a grep:

  • -i - búsqueda insensible a mayúsculas
  • -l - solo muestra el nombre del archivo donde se encontró la coincidencia
  • -h - solo muestra la línea que coincide (no el nombre del archivo)
51
RobEarl

grep ( GNU o BSD )

Puede usar la herramienta grep para buscar recursivamente la carpeta actual, como:

grep -r "class foo" .

Nota: -r - Busca de forma recursiva los subdirectorios.

También puede usar la sintaxis de globbing para buscar en archivos específicos como:

grep "class foo" **/*.c

Nota: Al usar opción de globbing (**), 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 usar **/*.* 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 limitar su búsqueda o use la sintaxis de find como:

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

Alternativamente, use ripgrep .

ripgrep

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

rg "class foo" .

Compruebe los documentos, los pasos de instalación o el código fuente en la página de proyecto de GitHub .

Es mucho más rápido que cualquier otra herramienta como GNU / BSDgrep , ucg , ag , sift , ack , pt o similar, ya que está construido sobre motor de expresiones regulares de Rust que usa autómatas finitos, SIMD y Optimizaciones literales agresivas para hacer búsquedas muy rápidas.

Admite los patrones de ignorar especificados en los archivos .gitignore, por lo que una única ruta de archivo se puede comparar con varios patrones globales simultáneamente.


Puede utilizar los parámetros comunes tales como:

  • -i - Búsqueda insensible.
  • -I - Ignora los archivos binarios.
  • -w - Busca las palabras completas (en oposición a la coincidencia parcial de Word).
  • -n - Muestra la línea de tu partida.
  • -C/--context (por ejemplo, -C5): aumenta el contexto, por lo que ve el código que lo rodea.
  • --color=auto - Marca 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.
50
kenorb
grep -insr "pattern" *
  • i: Ignore las distinciones entre mayúsculas y minúsculas tanto en el PATTERN como en los archivos de entrada.
  • n: Prefija cada línea de salida con el número de línea basado en 1 dentro de su archivo de entrada.
  • s: suprime los mensajes de error sobre archivos inexistentes o ilegibles.
  • r: Leer todos los archivos debajo de cada directorio, recursivamente.
38
enfinet

Tratar:

find . -name "*.txt" | xargs grep -i "text_pattern"
27
venkat

¿Cómo encuentro todos los archivos que contienen texto específico en Linux? (...)

Me encontré con esta solución dos veces:

find / -type f -exec grep -H 'text-to-find-here' {} \;


Si usaencuentrecomo en su ejemplo, mejor agregue -s (--no-messages) a grep, y 2>/dev/null al final del comando para evitar muchos Permiso denegado mensajes emitidos por grep y find:

find / -type f -exec grep -sH 'text-to-find-here' {} \; 2>/dev/null

findes la herramienta estándar para buscar archivos, combinada con grep cuando se busca texto específico, en plataformas similares a Unix. El comando find a menudo se combina con xargs , por cierto.

Existen herramientas más rápidas y fáciles para el mismo propósito, ver más abajo. Mejor inténtalos, siempre que estén disponibles en tu plataforma, por supuesto:

Alternativas más rápidas y fáciles.

RipGrep- herramienta de búsqueda más rápida:

rg 'text-to-find-here' / -l

El buscador de plata:

ag 'text-to-find-here' / -l

ack:

ack 'text-to-find-here' / -l

Nota: También puede agregar 2>/dev/null a estos comandos, para ocultar muchos mensajes de error.


Advertencia : a menos que realmente no pueda evitarlo, no busque desde '/' (el directorio raíz) para evitar una búsqueda larga e ineficiente ! Así que en los ejemplos anteriores, es mejor que sustituyas '/' por un nombre de subdirectorio, por ejemplo, "/ home" dependiendo de dónde quieras buscar ...

27
Bludzee

Hay una nueva utilidad llamada The Silversearcher

Sudo apt install silversearcher-ag

Trabaja estrechamente con Git y otros VCS. Por lo tanto, no obtendrá nada en un directorio .git u otro.

Usted puede simplemente utilizar

ag -ia "Search query"

¡Y hará la tarea por ti!

27
Neil Agarwal

Use pwd para buscar desde cualquier directorio en el que se encuentre, recurriendo hacia abajo

grep -rnw `pwd` -e "pattern"

Actualizar Dependiendo de la versión de grep que esté utilizando, puede omitir pwd. En las versiones más recientes, . parece ser el caso predeterminado para grep si no se proporciona un directorio así:

grep -rnw -e "pattern"

o

grep -rnw "pattern"

hará lo mismo que arriba!

26
mahatmanich

grep puede usarse incluso si no estamos buscando una cadena.

Simplemente corriendo,

grep -RIl "" .

imprimirá la ruta a todos los archivos de texto, es decir, aquellos que solo contienen caracteres imprimibles.

18
Alex Jasmin

Aquí están las varias listas de comandos que se pueden usar para buscar archivos.

grep "text string to search” directory-path

grep [option] "text string to search” directory-path

grep -r "text string to search” directory-path

grep -r -H "text string to search” directory-path

egrep -R "Word-1|Word-2” directory-path

egrep -w -R "Word-1|Word-2” directory-path
16
Atul Arvind

Un simple find puede trabajar a la mano. alias en su archivo ~/.bashrc:

alias ffind find / -type f | xargs grep

Iniciar un nuevo terminal y emitir:

ffind 'text-to-find-here'
14
danglingpointer
find /path -type f -exec grep -l "string" {} \;

Explicación de los comentarios.

find es 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 los archivos deben cumplir, enumera todos los objetos del directorio.

-type f specifies that it should proceed only files, not directories etc.
-exec grep specifies that for every found file, it should run grep command, passing its filename as an argument to it, by replacing {} with the filename
14
Vinod Joshi

Espero que esto sea de ayuda ...

La expansión de grep un poco para proporcionar más información en la salida, por ejemplo, para obtener el número de línea en el archivo donde se encuentra el texto, se puede hacer de la siguiente manera:

find . -type f -name "*.*" -print0 | xargs --null grep --with-filename --line-number --no-messages --color --ignore-case "searthtext"

Y si tiene una idea de qué tipo de archivo es, puede limitar su búsqueda especificando extensiones de tipo de archivo para buscar, en este caso .pas OR .dfm files:

find . -type f \( -name "*.pas" -o -name "*.dfm" \) -print0 | xargs --null grep --with-filename --line-number --no-messages --color --ignore-case "searchtext"

Breve explicación de las opciones:

  1. . en la find especifica desde el directorio actual.
  2. -name "*.*": para todos los archivos (-name "*.pas" -o -name "*.dfm"): Solo el *.pas OR *.dfm, ORespecificado con -o
  3. -type f especifica que estás buscando archivos
  4. Los -print0 y --null en el otro lado de | (pipe) son los cruciales, pasando el nombre de archivo de la find a la grep incrustada en la xargs, permitiendo el paso de los nombres de los archivos CON espacios en los nombres de los archivos, permitiendo que grep trate la ruta y el nombre de archivo como una cadena, y no lo rompa en cada espacio.
14
Gert van Biljon

Silver Searcher es una herramienta excelente, pero ripgrep puede ser aún mejor.

Funciona en Linux, Mac y Windows, y se escribió en Hacker News hace un par de meses (esto tiene un enlace al blog de Andrew Gallant que tiene un enlace de GitHub):

Ripgrep - Una nueva herramienta de búsqueda de línea de comandos

14
AAAfarmclub

Tratar:

find / -type f -exec grep -H 'text-to-find-here' {} \;

que buscará en todos los sistemas de archivos, porque / es la carpeta raíz.

Para el uso de la carpeta de inicio:

find ~/ -type f -exec grep -H 'text-to-find-here' {} \;

Para el uso de la carpeta actual:

find ./ -type f -exec grep -H 'text-to-find-here' {} \;
14
user4863663

Escribí un script de Python que hace algo similar. Así es como uno debe usar este script.

./sniff.py path pattern_to_search [file_pattern]

El primer argumento, path, es el directorio en el que buscaremos de forma recursiva. El segundo argumento, pattern_to_search, es una expresión regular que queremos buscar en un archivo. Usamos el formato de expresión regular definido en la biblioteca Pythonre. En este script, el . también coincide con la nueva línea.

El tercer argumento, file_pattern, es opcional. Esta es otra expresión regular que funciona en un nombre de archivo. Solo se considerarán aquellos archivos que coincidan con esta expresión regular.

Por ejemplo, si quiero buscar archivos de Python con la extensión py que contiene Pool( seguido de Word Adaptor, hago lo siguiente:

./sniff.py . "Pool(.*?Adaptor"  .*py
./Demos/snippets/cubeMeshSigNeur.py:146 
./Demos/snippets/testSigNeur.py:259 
./python/moose/multiscale/core/mumbl.py:206 
./Demos/snippets/multiComptSigNeur.py:268 

Y listo, genera la ruta de los archivos coincidentes y el número de línea en el que se encontró la coincidencia. Si se encontró más de una coincidencia, entonces cada número de línea se agregará al nombre del archivo.

13
Dilawar

Utilizar:

grep -c Your_Pattern *

Esto informará cuántas copias de su patrón hay en cada uno de los archivos en el directorio actual.

12
Dr_Hope

grep es tu buen amigo para lograrlo.

grep -r <text_fo_find> <directory>

si no te importa el caso del texto para encontrarlo, usa

grep -ir <text_to_find> <directory>
11
Prash

Todas las respuestas anteriores sugieren grep y encontrar. Pero hay otra manera: Use Midnight Commander

Es una utilidad gratuita (30 años, probada por el tiempo) que es visual sin ser GUI. Tiene toneladas de funciones, y encontrar archivos es solo una de ellas.

11
Peter M.

Para buscar la cadena y generar 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 del 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;
11
user3124504

Existe una herramienta ack que haría exactamente lo que está buscando.

http://linux.die.net/man/1/ack

ack -i search_string folder_path/*

Puede ignorar -i para la búsqueda sensible a mayúsculas y minúsculas

11
Pal

El siguiente comando funcionará bien para este enfoque:

find ./ -name "file_pattern_name"  -exec grep -r "pattern" {} \;
10
Pradeep Goswami

Prueba esto:

find . | xargs grep 'Word' -sl
10
Tayab Hussain

Me fascina lo simple que lo hace grep con 'rl'

grep -rl 'pattern_to_find' /path/where/to/find

-r to find recursively file / directory inside directories..
-l to list files matching the 'pattern'

Utilice '-r' sin 'l' para ver los nombres de los archivos seguidos por texto en el que se encuentra el patrón !

grep -r 'pattern_to_find' /path/where/to/find

Funciona simplemente perfecto ..

¡Espero eso ayude!

10
nitinr708

Puede usar el siguiente comando ya que no desea el nombre del archivo, pero desea buscar en todos los archivos. Aquí estoy capturando el formulario "TEXTO" Todos los archivos de registro asegurándose de que el nombre del archivo no se imprima

grep -e TEXT *.log | cut -d' ' --complement -s -f1

la opción grep con -e es bastante rápida en comparación con otra opción, ya que es para la coincidencia de PATTERN

10
Mitul Patel

Evita la molestia e instala ack-grep. Se elimina una gran cantidad de problemas de permisos y citas.

apt-get install ack-grep

Luego vaya al directorio que desea buscar y ejecute el siguiente comando

cd /
ack-grep "find my keyword"
10
Kareem

Se prefiere find con xargs cuando hay muchas coincidencias potenciales para analizar. Se ejecuta más lentamente que otras opciones, pero siempre funciona. Como algunos han descubierto, xargs no maneja archivos con espacios incrustados de forma predeterminada. Puedes superar esto especificando la opción -d.

Aquí está la respuesta de @ RobEarl, mejorada para que maneje archivos con espacios:

find / -type f | xargs -d '\n' grep 'text-to-find-here'

Aquí está la respuesta de @venkat, similarmente mejorada:

find . -name "*.txt" | xargs -d '\n' grep -i "text_pattern"

Aquí está la respuesta de @Gert van Biljon, similarmente mejorada:

find . -type f -name "*.*" -print0 | xargs -d '\n' --null grep --with-filename --line-number --no-messages --color --ignore-case "searthtext"

Aquí está la respuesta de @LetalProgrammer, similarmente mejorada:

alias ffind find / -type f | xargs -d '\n' grep

Aquí está la respuesta de @Tayab Hussain, mejorada de manera similar:

find . | xargs -d '\n' grep 'Word' -sl
7
Mike Slinn

Si tiene un conjunto de archivos que siempre estará verificando, puede alias sus rutas, por ejemplo:

alias fd='find . -type f -regex ".*\.\(inc\|info\|module\|php\|test\|install\|uninstall\)"'

Entonces simplemente puede filtrar la lista de esta manera:

grep -U -l $'\015' $(fd)

Que filtra la lista fd a los archivos que contienen el patrón CR.

Me parece que el alias de los archivos que me interesan me ayuda a crear scripts más fáciles y siempre trato de recordar cómo obtener todos esos archivos. Las cosas recursivas también funcionan, pero tarde o temprano tendrás que lidiar con eliminar tipos de archivos específicos. Es por eso que, para empezar, encuentro todos los tipos de archivos que me interesan.

7
dkinzer

Si desea utilizar estrictamente find entonces:

find /path/to/somewhere/ -type f -exec grep -nw 'textPattern' {} \;

find + grep

1. Utilice find para buscar archivos, 2. Luego ejecute grep en todos ellos.

Se puede combinar en un comando de la siguiente manera:

find /path/to/somewhere/ -type f -exec grep -nw 'textPattern' {} \;

  • Use -name Pattern si quiere grep solo ciertos archivos:

    find /path/to/somewhere/ -type f -name \*.cpp -exec grep -nw 'textPattern' {} \;

Esto puede darle el poder de find para encontrar archivos. Puedes jugar con él y usar diferentes opciones de find para mejorar o limitar tu búsqueda de archivos.

7
BreakBadSP

Prueba esto:

find / -type f -name "*" -exec grep -il "String_to_search" {} \;

O

for i in /*;do grep -Ril "String_to_search" $i;done 2> /dev/null
7
VIPIN KUMAR

Utilizar:

grep -Erni + "text you wanna search"

El comando buscará recursivamente en todos los archivos y directorios del directorio actual e imprimirá el resultado.

Nota: si la salida de grep no está coloreada, puede cambiarla utilizando el alias grep = 'grep --color = always' en su archivo fuente de Shell.

7
baldash

Puedes usar los siguientes comandos para encontrar un texto particular de un archivo:

cat file | grep 'abc' | cut -d':' -f2
7
iamjayp

Como Peter en la respuesta anterior mencionó , todas las respuestas anteriores sugieren grep y find.

Pero hay una forma más sofisticada de usar Gnome Commander con una perfectaGUIy con toneladas de opciones desde 2001, y encontrar archivos es solo una de ellas. También es una utilidad gratuita, probada por el tiempo.

7
Geeocode

Prueba esto

find . -type f -name some_file_name.xml -exec grep -H PUT_YOUR_STRING_HERE {} \;
6
Sireesh Yarlagadda

Vea también The Platinum Searcher , que es similar a The Silver Searcher y está escrito en Go.

Ejemplo:

pt -e 'text to search'
5
Gustavo Paulo

Alternativa de búsqueda GUI - Para uso de escritorio:

- Como la pregunta no es precisamente pedir comandos

Searchmonkey : herramienta avanzada de búsqueda de archivos sin tener que indexar su sistema usando expresiones regulares. Gráfico equivalente a encontrar/grep. Disponible para Linux (Gnome/KDE/Java) y Windows (Java) - código abierto GPL v3

Características:

  • Expresiones regulares avanzadas
  • Resultados mostrados en contexto
  • Búsqueda que contiene texto
  • Panel para mostrar la línea que contiene texto.
  • Nuevas actualizaciones de 2018
  • etc.

Descargar - Enlaces:

.

Captura de pantalla:

 Enter image description here

5
intika

tu orden es correcta Solo necesito agregar -l a grep.

find / -type f -exec grep -l 'text-to-find-here' {} \;
0
FariZ