Cómo buscar archivos y texto utilizando find y grep

¿Qué diferencia hay entre find y grep?

En una terminal —la interfaz de texto donde se escriben comandos, uno por línea— find y grep están entre los comandos que más se usan para ubicar algo entre miles de archivos, y aparecen en cualquier repaso de comandos útiles de Linux. Pero apuntan a preguntas distintas, y confundirlas es la causa de la mayoría de las búsquedas fallidas.

find responde preguntas sobre los atributos de un archivo o directorio: nombre, tipo, fecha de modificación, tamaño. Recorre el árbol de directorios y evalúa cada entrada, sin abrir nunca el archivo para ver qué hay escrito adentro.

grep —de global regular expression print, heredado de un comando del editor ed— hace lo opuesto: lee cada archivo línea por línea y lo compara contra un patrón de texto o una expresión regular (una secuencia que describe un conjunto de cadenas posibles, no una sola palabra). Su salida son líneas que coinciden, no rutas.

Para atributos, find; para contenido, grep; para las dos cosas a la vez, una tubería.

Cómo buscar archivos con find

La sintaxis general de find es find [ruta...] [expresión]. Si no indicás una ruta, busca desde el directorio actual. La expresión combina pruebas (condiciones sobre cada entrada) y, si hace falta, acciones sobre lo que encuentra; sin una acción explícita, find simplemente imprime la ruta de cada coincidencia.

find . -name "*.log"
find /var/log -type f -name "*.log"
find . -type d -name "node_modules"
find /home/usuario -mtime -7
find . -size +100M
find /var/www -type f -name "*.php" -mtime -1

La primera busca archivos .log desde el directorio actual; la segunda limita el tipo y la ruta a /var/log, uno de los directorios que la estructura de directorios de Linux (FHS) reserva para registros del sistema; la tercera busca directorios node_modules; la cuarta lista lo modificado en la última semana; la quinta filtra por tamaño; la última combina tipo, nombre y fecha en una sola expresión.

Por defecto find une varias pruebas con un «y» lógico implícito: una entrada tiene que cumplirlas todas para aparecer en el resultado.

Acciones de find: -exec {} \; frente a {} + y -delete

Encontrar rutas no siempre alcanza: a veces hace falta hacer algo con cada una, y las dos formas de cerrar -exec se comportan de manera muy distinta.

-exec comando {} \; ejecuta el comando una vez por cada archivo; {} se reemplaza por la ruta, y el punto y coma se escapa con \ porque, sin escapar, la terminal lo tomaría como el fin de su propia instrucción. Con mil archivos, arranca mil procesos, uno detrás de otro.

-exec comando {} + agrupa tantos nombres como puede en cada invocación, como xargs: resuelve el mismo trabajo con uno o unos pocos procesos. Por eso conviene siempre que el comando acepte varios argumentos —chmod, rm, grep—; {} \; solo tiene sentido si cada invocación necesita ser independiente.

# Una invocación por archivo: más procesos, más lento en árboles grandes
find . -name "*.tmp" -exec rm {} \;

# Una sola invocación agrupando varios archivos: más eficiente
find . -name "*.tmp" -exec rm {} +

# Dar permisos de ejecución a todos los scripts .sh de una vez
find . -type f -name "*.sh" -exec chmod +x {} +

find también trae -delete, más directa que -exec rm {} \; porque no depende de otro proceso. Antes de borrar de verdad:

• Corré primero la misma expresión con -print y revisá la lista completa.
• Restringí ruta y pruebas todo lo posible antes de una acción destructiva.
• -delete no pide confirmación ni usa papelera: es irreversible.

El error más común: espacios, -print0 y xargs -0

Por defecto, find imprime una ruta por línea. El problema aparece al enviar ese resultado por una tubería a xargs —el comando que convierte líneas de entrada en argumentos de otro comando—, porque sin opciones separa los argumentos por espacios y saltos de línea. Un archivo llamado informe final.txt se parte en dos argumentos, informe y final.txt, y el comando siguiente recibe dos rutas inexistentes en vez de una.

# Se rompe si algún nombre tiene espacios
find . -name "*.txt" | xargs grep -l "REVISAR"

# Sobrevive a espacios, saltos de línea y comillas en el nombre
find . -name "*.txt" -print0 | xargs -0 grep -l "REVISAR"

La solución es el par -print0 y xargs -0. -print0 le dice a find que termine cada ruta con un byte nulo en lugar de un salto de línea; xargs -0 interpreta la entrada de esa misma manera. Como un byte nulo nunca forma parte de un nombre de archivo válido en Linux, sirve como separador inequívoco: no importa si el nombre tiene espacios, tabulaciones o comillas, llega entero al otro lado de la tubería. Es, con diferencia, el error más frecuente al combinar find con grep a través de xargs.

Cómo buscar texto con grep

Esta sección retoma un aporte de la comunidad: el hilo «A brief introduction to Linux | Part XI: Expresiones regulares y Metacaracteres», de TerminusRoot en el foro de Underc0de, ya explicaba con ejemplos reales buena parte de lo que sigue —-v, -n, -i, -E, las anclas ^ y $, el punto como comodín y el escapado con \—. Sigue vigente; esta guía lo reorganiza junto con la parte de find, sin hilo equivalente en el foro.

La sintaxis general es grep [opciones] patrón [archivo...]: lee cada archivo línea por línea y, por defecto, imprime las líneas donde aparece el patrón.

grep -n "error" /var/log/syslog
grep -i "error" /var/log/syslog
grep -v "^#" /etc/ssh/sshd_config
grep -rl "REVISAR" ./src
grep -r --include="*.py" "import os" .

La primera muestra coincidencias de «error» con número de línea; la segunda hace lo mismo sin distinguir mayúsculas; la tercera invierte la búsqueda y muestra lo que no empieza con #, útil para revisar la configuración activa de un archivo lleno de comentarios; la cuarta busca de forma recursiva y solo lista los archivos con coincidencias; la última limita esa búsqueda a archivos .py.

BRE, ERE y PCRE: qué cambia de verdad

Una expresión regular es un patrón que describe un conjunto de cadenas posibles, no una sola palabra literal. POSIX define dos modos, y GNU grep agrega un tercero que ya no es POSIX.

Las expresiones regulares básicas (BRE) son el modo por defecto de grep. En este modo, metacaracteres como +, ?, |, ( y ) no tienen significado especial a menos que los escapes con una barra invertida: \+, \?, \|, \(, \). Las expresiones regulares extendidas (ERE, con -E) invierten la regla: esos símbolos tienen significado especial de forma directa, y escaparlos se lo quita.

# BRE (por defecto): la alternancia necesita escape
grep "fail\|error" registro.log

# ERE: la alternancia es directa
grep -E "fail|error" registro.log

# Anclas de comienzo y fin de línea, iguales en BRE y ERE
grep "^root:" /etc/passwd
grep "bash$" /etc/passwd

# BRE: el "?" opcional necesita escape
grep "colou\?r" texto.txt
# ERE: el "?" es directo
grep -E "colou?r" texto.txt

# PCRE, no garantizado en todas las implementaciones de grep
grep -P "\d{3}-\d{4}" contactos.txt

Las anclas ^ y $ y el punto . como comodín funcionan igual en los dos modos POSIX; lo que cambia es solo el tratamiento de los metacaracteres de agrupación y repetición.

Si un patrón con |, + o ? no hace lo que esperás, fijate si estás en BRE sin escapar el símbolo, o si olvidaste -E.

Combinar find y grep con una tubería

La guía de redirecciones y tuberías en la terminal cubre la mecánica general de conectar la salida de un comando con la entrada del siguiente. Acá importa por qué conviene unir find y grep: ninguno cubre solo una búsqueda que combine atributos y contenido.

# Archivos .log que contienen "OutOfMemory"
find . -name "*.log" -print0 | xargs -0 grep -l "OutOfMemory"

# Archivos de /etc modificados después de /etc/hostname, que mencionan PermitRootLogin
find /etc -type f -newer /etc/hostname -print0 | xargs -0 grep -l "PermitRootLogin"

# Scripts Python modificados en los últimos 30 días con una marca REVISAR pendiente
find . -type f -name "*.py" -mtime -30 -print0 | xargs -0 grep -n "REVISAR"

# Alternativa sin xargs: -exec ya pasa el nombre completo, no hace falta -print0
find . -name "*.conf" -exec grep -l "Listen" {} +

El último ejemplo importa: con -exec grep ... {} +, find pasa los nombres directamente al comando, así que el problema de los espacios ni aparece. Estos patrones son los que después vas a encapsular dentro de un script de Bash para repetirlos con variables en lugar de reescribirlos cada vez.

Errores frecuentes

• Combinar find con xargs sin -print0/-0. Funciona con nombres simples y se rompe con el primer archivo que tiene un espacio.
• Elegir {} \; por costumbre en árboles grandes. Si el comando acepta varios argumentos, {} + hace el mismo trabajo con menos procesos.
• Usar | en grep básico sin -E ni escaparla. En BRE, | es literal hasta que lo escapás o activás -E.
• Creer que grep -i y find -iname cubren lo mismo. Uno mira el contenido; el otro, el nombre del archivo.
• Correr -delete o -exec rm sin probar antes con -print. Ninguna pide confirmación ni tiene deshacer.
• Dejar el patrón sin comillas. La terminal puede expandir comodines antes de que grep o find los reciban.

Preguntas frecuentes

Fuentes

Aportes de la comunidad y documentación oficial consultados para esta guía. Fecha de consulta: 29 de julio de 2026.

Aportes de la comunidad Underc0de

1. Underc0de, foro. A brief introduction to Linux | Part XI: Expresiones regulares y Metacaracteres, por TerminusRoot, sección GNU/Linux. Origen de la sección de grep y expresiones regulares de esta guía: cubre -v, -n, -i, -E, las anclas ^ y $, el punto como comodín y el escapado con barra invertida, y sigue vigente.

La parte de find de esta guía no se apoya en ningún hilo del foro: no existe un aporte previo de la comunidad sobre este comando, así que esa sección es contenido nuevo. La parte VI de la misma serie de TerminusRoot, «Operaciones de Archivos y Directorios», es una lectura relacionada sobre manejo de archivos en la terminal, pero no trata find.

Documentación oficial

1. man7.org. find(1). Sintaxis completa de pruebas y acciones de find.
2. man7.org. grep(1). Opciones de grep y comportamiento por defecto.
3. man7.org. xargs(1). Comportamiento de -0 y el problema de separación por espacios.
4. GNU. GNU grep Manual. Detalle de BRE, ERE y las extensiones PCRE de GNU grep.
5. GNU. GNU Findutils Manual. Referencia extendida de find, incluida la diferencia entre -exec {} \; y -exec {} +.
6. The Open Group. POSIX Base Specifications — grep. Definición estándar del comportamiento de grep.
7. The Open Group. POSIX Base Specifications — find. Definición estándar de find.
8. The Open Group. POSIX Base Specifications — Regular Expressions. Definición formal de BRE y ERE.