Ejemplos del comando find en Linux paso a paso

Si trabajas a menudo con la terminal de GNU/Linux, tarde o temprano necesitas un buen buscador de archivos desde línea de comandos. Ahí es donde entra en juego el comando find, uno de esos viejos conocidos del mundo UNIX que al principio intimidan, pero que, una vez les pillas el truco, se vuelven imprescindibles.

Con find puedes localizar archivos y directorios en un árbol de carpetas usando casi cualquier criterio que puedas imaginar: nombre, extensión, tamaño, fechas de acceso o modificación, permisos, propietario, grupo, tipo de fichero (normal, directorio, enlace simbólico…), nivel de profundidad e incluso combinaciones lógicas de varias condiciones.

Qué es exactamente el comando find y cómo se usa

El comando find forma parte de las utilidades clásicas de UNIX y está disponible en prácticamente cualquier distribución GNU/Linux. A diferencia de herramientas como locate, que usan una base de datos, find recorre el sistema de archivos en tiempo real, por lo que siempre trabaja con información actualizada.

La sintaxis general de find suele escribirse así:

find

En esta estructura, la ruta inicial indica desde dónde empieza la búsqueda. Puede ser la raíz / para todo el sistema, el directorio actual ., tu carpeta personal ~ o cualquier ruta absoluta o relativa que necesites.

Tras la ruta se indican las opciones y expresiones de filtrado: por nombre, tipo, tamaño, tiempo, permisos, propietario, etc. Estas condiciones se pueden combinar y también acompañar de una acción final (por ejemplo, borrar, copiar, listar en detalle) usando parámetros como -exec o integrando xargs.

Buscar archivos y directorios por nombre

El uso más frecuente de find es el de buscar por nombre o patrón de nombre, bien sea un archivo concreto o un grupo de ficheros que coinciden con una expresión.

Para localizar un archivo con un nombre concreto desde el directorio actual y descendiendo por sus subcarpetas, bastaría con una orden como:

find . -name archivo22.txt

Este comando muestra todas las rutas en las que aparece un archivo con ese nombre exacto. Si quieres acotar la búsqueda a una carpeta distinta, puedes escribir, por ejemplo:

find ./prueba -name archivo22.txt

También puedes utilizar comodines para capturar varios ficheros a la vez. Por ejemplo, para localizar todos los elementos cuyo nombre empiece por “archivo” en un directorio concreto:

find ./prueba -name "archivo*"

Si lo que necesitas es buscar por extensión, el patrón clásico sería algo así:

find . -name "*.txt"

Aquí le estás diciendo a find que devuelva todos los archivos y directorios cuyo nombre termine en .txt, empezando en la ubicación actual. Para un directorio distinto, basta con cambiar la ruta inicial:

find /ruta/a/buscar -name "*.html"

Ten en cuenta que el parámetro -name distingue mayúsculas y minúsculas. Si no tienes claro cómo está escrito (por ejemplo, “mystuff”, “MyStuff”, “MYSTUFF”…) lo más cómodo es usar -iname:

find . -iname "mystuff"

Con -iname se hace una búsqueda sin distinción entre mayúsculas y minúsculas, algo muy útil cuando solo recuerdas parte del nombre aproximado.

Controlar el tipo de resultado: solo archivos, solo directorios, enlaces, etc.

Por defecto find puede devolver tanto archivos normales como directorios y otros tipos de entradas. Para limitar el resultado, se usa la opción -type con una letra que indica el tipo de fichero.

Los tipos más habituales son f para archivos regulares, d para directorios y l para enlaces simbólicos, aunque hay más (caracteres, bloques, sockets, etc.). Por ejemplo, para buscar solo archivos (no carpetas) con cierto nombre:

find . -type f -name "mystuff"

Si, al contrario, lo que quieres es localizar directorios concretos, usarías:

find . -type d -name "qa*"

También se puede combinar el tipo con la extensión. Un caso típico: encontrar todos los archivos de código C++ en tu proyecto:

find . -type f -name "*.cpp"

Es importante encerrar el patrón entre comillas para evitar que el shell expanda el asterisco antes de que find lo procese. Si no lo haces, el comodín se sustituirá por los nombres presentes en el directorio actual y es fácil que el comando deje de funcionar como esperas.

Cuando quieres que find trabaje sobre varios directorios a la vez, puedes listarlos todos al inicio del comando:

find ./location1 /second/location -type f -name "pattern"

Limitar la profundidad de la búsqueda y excluir rutas

De serie, find recorre todas las subcarpetas de forma recursiva. A veces eso es demasiado, por ejemplo si solo te interesa lo que hay en el directorio actual. Para controlar la profundidad se usa -maxdepth y, opcionalmente, -mindepth.

Si quieres que solo se mire el nivel actual y no se entren subdirectorios, puedes usar:

find . -maxdepth 1 -type f -name "*.txt"

El parámetro -mindepth te permite, por ejemplo, ignorar el propio directorio de inicio y empezar a devolver resultados a partir del primer nivel interior.

Otra necesidad habitual es excluir directorios concretos de la búsqueda. Para ello se combina -path con -prune y el operador -o (OR). Un ejemplo clásico sería:

find . -path "./directory_exclude/*" -prune -o -name "SEARCH_NAME"

Aquí -prune indica que no se descienda por la ruta indicada, y con -o se dice que el resto de condiciones solo se evalúen para lo que no ha sido “podado”. Es un truco muy útil para saltarse, por ejemplo, carpetas de copias de seguridad, directorios temporales o repositorios pesados.

Buscar por tamaño: archivos grandes, pequeños y rangos

El parámetro -size permite filtrar archivos en función de su tamaño. Es especialmente práctico para detectar ficheros enormes que ocupan demasiado espacio o para limpiar archivos minúsculos innecesarios.

La forma básica es:

find -size N

Las unidades más habituales son c (bytes), k (KB), M (MB) y G (GB). El número puede ir precedido por + (mayor que), – (menor que) o sin prefijo (tamaño exacto). Por ejemplo, para buscar ficheros de exactamente 300 MB:

find . -size 300M

Si lo que quieres es encontrar todo lo que pese más de 300 MB:

find . -size +300M

Para localizar archivos más pequeños de 300 MB:

find . -size -300M

También es posible definir rangos de tamaño. Por ejemplo, ficheros entre 270 y 300 MB:

find . -size +270M -size -300M

Si necesitas algo más al límite, puedes buscar, por ejemplo, archivos de más de 1 GB o más de 500 MB en todo el sistema:

find / -size +1G

find / -size +500M

Y por supuesto, combinar tamaño con nombre. Un caso típico: ficheros de log gigantes en la raíz:

find / -size +500M -name "*.log"

Buscar archivos vacíos y directorios vacíos

Los sistemas se llenan con el tiempo de archivos y carpetas vacías que ya no sirven de nada. Find ofrece la opción -empty para detectarlos de forma rápida.

Para encontrar cualquier cosa vacía (archivos o directorios):

find . -empty

Si solo te interesan archivos vacíos, puedes concretar el tipo:

find . -type f -empty

Y si lo que buscas son directorios vacíos:

find . -type d -empty

Una vez localizados, se pueden combinar con acciones para borrarlos automáticamente si estorban, algo que veremos más adelante con -delete y -exec.

Búsquedas por fecha: mtime, atime, ctime, minutos y rangos

GNU/Linux registra para cada archivo tres marcas de tiempo básicas: cuándo se accedió, cuándo se modificó su contenido y cuándo cambiaron sus metadatos (permisos, propietario, etc.). Find puede filtrar en base a cualquiera de ellas.

Los parámetros más importantes son:

• -atime / -amin: basados en el tiempo de último acceso (días o minutos).
• -mtime / -mmin: basados en la última modificación del contenido.
• -ctime / -cmin: basados en el último cambio de estado (permisos, propietario, enlaces, etc.).

Para encontrar archivos modificados hace más de 7 días en la ruta actual:

find . -mtime +7

Si lo que buscas es archivos accedidos hace menos de 15 días:

find . -atime -15

También puedes jugar con rangos de tiempo. Un ejemplo: ficheros cuyo estado cambió entre 2 y 6 minutos atrás:

find . -cmin +2 -cmin -6

Cuando necesitas un control más fino en minutos, entran en juego -mmin, -amin y -cmin. Por ejemplo, archivos cuyo contenido se modificó en los últimos 5 minutos:

find . -type f -mmin -5

O ficheros Java modificados entre hace 20 y 30 minutos, combinando nombre y rango:

find . -type f -mmin +20 -mmin -30 -name "*.java"

Otra opción interesante es -newer, que permite comparar fechas entre archivos. Por ejemplo, para obtener todos los ficheros más recientes que un determinado archivo de referencia:

find / -newer mi_archivo

Filtrar por propietario, grupo y ficheros huérfanos

En sistemas multiusuario o servidores es muy útil poder localizar archivos según su propietario o grupo, por ejemplo para revisar qué tiene cada cuenta o detectar cosas raras.

Para encontrar todos los ficheros pertenecientes al usuario “juan” en el directorio actual:

find . -type f -user juan

Si además solo te interesan, digamos, ciertos tipos de archivo, puedes añadir la condición de nombre:

find . -type f -user juan -name "*.cpp"

Con la opción -group haces lo mismo, pero por grupo. Por ejemplo, ficheros del grupo “flossblog”:

find . -group flossblog -type f

Find también admite rangos de UID y GID usando -uid y -gid, lo que permite localizar ficheros pertenecientes a un conjunto de usuarios numéricamente. Por ejemplo, archivos de usuarios cuyo UID se encuentre entre 500 y 1000 (sin incluir los extremos):

find . -uid +500 -uid -1000 -type f

Además, existen los filtros -nouser y -nogroup, muy útiles para detectar ficheros huérfanos, es decir, que no pertenecen a ningún usuario o grupo válido del sistema:

find . -nouser

find . -nogroup

Buscar por permisos y modos de acceso

El parámetro -perm permite encontrar archivos según sus permisos, bien sea de forma exacta o en base a ciertos bits concretos. También hay atajos como -readable, -writable y -executable para filtrar por lo que tu usuario actual puede hacer.

Para localizar todos los archivos que el usuario actual puede leer:

find . -readable

Si quieres saber qué ficheros puedes modificar:

find . -writable

Y para aquellos que son ejecutables para ti:

find . -executable

Cuando necesitas trabajar con modos numéricos tipo 644, 755, 777, etc., la sintaxis es:

find . -perm 777

En este caso, se buscan ficheros cuyo modo coincide exactamente con 777. Sin embargo, -perm admite prefijos que cambian el comportamiento:

• Sin prefijo: coincide solo si el modo es exactamente el indicado.
• Con – delante: el archivo tiene al menos esos permisos (puede tener más).
• Con / delante: coincide si cualquiera de los bits de PMODE está presente.

Por ejemplo, para localizar todos los ficheros cuyo propietario y grupo tienen lectura y escritura, y el resto lectura, de forma exacta:

find . -perm 664

Si añades el prefijo -, también saldrán ficheros como 666, 777, 776, siempre que contengan al menos los bits de 664:

find . -perm -664

Por otro lado, buscando con /222 obtendrás ficheros que pueden ser escritos por alguien (propietario, grupo u otros):

find . -perm /222

Optimización del rendimiento: opciones -O1, -O2 y -O3

En sistemas con árboles de directorios enormes, la eficiencia de find puede marcar la diferencia. GNU findutils proporciona niveles de optimización mediante las opciones -O1, -O2 y -O3.

Con -O1 se usa la configuración por defecto, priorizando pruebas de nombre de archivo frente a otras que consumen más recursos. Por ejemplo:

find -O1 /ruta -name "*.html"

La opción -O2 permite que find ordene internamente los tests de nombre y tipo de archivo antes del resto, optimizando aún más el recorrido:

find -O2 /ruta -type f -name "*.html"

Por último, -O3 deja que el propio find reorganice los filtros en función de la probabilidad de éxito y el coste, buscando la máxima eficiencia global:

find -O3 /ruta -name "*.html"

Combinar condiciones: AND, OR, NOT y expresiones regulares

Una de las grandes fortalezas de find es que permite combinar múltiples condiciones lógicas. De hecho, internamente trabaja con una especie de lenguaje de expresiones que puedes ir componiendo.

Para unir condiciones con AND se puede usar explícitamente -and o simplemente dejar un espacio entre condiciones (AND es el comportamiento por defecto). Por ejemplo, ficheros entre 500 MB y 1 GB:

find /ruta -size +500M -and -size -1G

Con -or (o abreviado -o) puedes buscar archivos que cumplan al menos una de varias condiciones. Por ejemplo, documentos DOCX u ODT:

find /ruta -name "*.docx" -or -name "*.odt"

Si quieres excluir algo, dispones de -not o el símbolo ! (normalmente con barra invertida delante para que el shell no lo interprete). Por ejemplo, archivos .docx que no sean .odt:

find /ruta -name "*.docx" -not -name "*.odt"

Find también soporta expresiones regulares completas usando -regex y -regextype. Con ello se pueden construir filtros muy finos, como por ejemplo directorios de proyectos que no sean copias, ni versiones antiguas ni tengan ciertos sufijos. Un patrón algo más elaborado podría ser:

PATTERN=".*/((.*(|old|ba?c?ku?ps?))|(..*)|(copy|new|backup|back|).*)$"

find proyectos -maxdepth 1 -mindepth 1 -regextype posix-egrep ! -iregex "$PATTERN" ! -empty -type d

Usar find junto con grep para buscar por contenido

Aunque find es tremendamente flexible, no analiza el contenido de los archivos por sí mismo; se centra en nombres y metadatos. Para buscar texto dentro de los ficheros, lo habitual es combinarlo con grep.

Una forma típica de hacerlo es mediante -exec:

find /ruta -type f -exec grep -i "palabra" {} \; -print

Aquí, find pasa cada archivo encontrado a grep, que busca el texto indicado (ignorando mayúsculas y minúsculas con -i). La opción -print hace que se muestren las rutas de los archivos que contienen ese patrón.

Si quieres hacerlo más eficiente, puedes integrar xargs en Linux para agrupar archivos en lotes en lugar de ejecutar grep una vez por cada fichero:

Otro patrón muy habitual consiste en localizar archivos PHP, de configuración u otros específicos y buscar dentro cierto texto, como un token, una URL o el nombre de una función. Por ejemplo:

find proyectos -name "*.php" -type f -print0 | xargs -0 grep -l "ireg"

Actuar sobre los resultados: -exec, xargs y -delete

Hasta ahora nos hemos centrado en cómo localizar archivos, pero la verdadera magia viene cuando usas find para ejecutar acciones sobre esos resultados. Las herramientas clave para esto son -exec, xargs y la opción -delete.

Usar -exec para lanzar comandos sobre cada archivo

La forma genérica y ejemplos de uso avanzado de -exec es:

find -exec comando {} +

Las llaves {} actúan como marcador de posición que se sustituye por los archivos encontrados, y el + indica que se pasen tantos ficheros como sea posible en cada ejecución del comando (lo que suele ser más eficiente).

Por ejemplo, para hacer un listado largo (ls -l) de todos los .txt encontrados:

find . -type f -name "*.txt" -exec ls -l {} +

Otra variante muy usada es terminar -exec con \; en lugar de +, lo que hace que el comando se ejecute una vez por archivo:

find . -type f -name "*.txt" -exec ls -l {} \;

Esto es menos eficiente, pero tiene la ventaja de que puedes usar {} más de una vez en la misma orden. Por ejemplo, para renombrar todos los .txt añadiendo la extensión .old:

find . -type f -name "*.txt" -exec mv {} {}.old \;

Usar xargs con find

Muchos usuarios se sienten más cómodos con la tubería clásica (pipe). Aquí es donde entra xargs, que recoge líneas de la entrada estándar y las pasa como argumentos a un comando.

Un ejemplo sencillo: listar con detalle todos los .txt de forma agrupada:

find . -type f -name "*.txt" | xargs ls -l

Cuando existe riesgo de rutas con espacios o caracteres raros, es muy recomendable usar -print0 en find y -0 en xargs, como en el ejemplo anterior con grep.

Buscar y cambiar permisos masivamente

Una tarea recurrente es ajustar permisos de muchos archivos a la vez, por ejemplo, poner todos los .php de un proyecto en 755:

find ver -name "*.php" -type f -exec chmod 755 {} \;

También es posible primero filtrar por permisos actuales y luego modificarlos. Por ejemplo, buscar archivos con modo 644 y pasarlos a 655:

find . -type f -perm 644 -exec chmod 655 {} \;

En el caso de directorios, podrías localizar los que tengan permisos 644 y cambiarlos a 755 para que sean ejecutables (accesibles):

find . -type d -perm 644 -exec chmod 755 {} \;

Copiar y mover archivos encontrados con find

Otro uso típico consiste en copiar o mover archivos que cumplen ciertos criterios a otras ubicaciones, ya sea como copia de seguridad, reorganización o archivado.

Por ejemplo, copiar un archivo concreto a un directorio de destino:

find . -iname "archivo22.txt" -exec cp {} ~/tmp/imagenes \;

O copiar todas las imágenes .jpg encontradas al mismo directorio de imágenes:

find . -iname "*.jpg" -exec cp {} ~/tmp/images \;

También puedes recorrer una lista de directorios de destino y copiar en todos ellos un archivo dado:

find ~/tmp/dir1/ ~/tmp/dir2/ $HOME/3/ -maxdepth 0 -exec cp ~/numeric/hci {} \;

Para mover archivos en lugar de copiarlos, simplemente sustituyes cp por mv. Por ejemplo, mover un archivo concreto:

find ~/folder/ -type f -name "universal.php" -exec mv {} ~/numeric/ \;

O trasladar todos los .php de un sitio a otro:

find ~/numeric/ -type f -name "*.php" -exec mv {} ~/folder/ \;

Incluso puedes mover por patrón de nombre, por ejemplo, todos los ficheros cuyo nombre empiece por “uni” sin importar la extensión:

find . -type f -name "uni*.*" -exec mv {} ~/unifiles/ \;

Si combinas con filtros de antigüedad, es sencillo montar tareas de archivado. Por ejemplo, mover a un directorio de backup todos los PDF de más de 20 días:

find /ruta/ -type f -name "*.pdf" -mtime +20 -exec mv {} /backup1/ \;

Borrar archivos y directorios con find (con cuidado)

Find también se usa mucho para eliminar archivos y carpetas masivamente, algo potentísimo pero que hay que manejar con mucha cabeza, sobre todo si se ejecuta como root.

La forma más directa de borrar solo archivos que cumplan un patrón es algo como:

find . -type f -name "til*" -exec rm {} \;

Para eliminar solo directorios que empiecen por til:

find . -type d -name "til*" -exec rm -rf {} \;

Si quieres borrar tanto ficheros como carpetas que coincidan con el patrón:

find . -name "til*" -exec rm -rf {} \;

Un caso muy habitual es eliminar todos los archivos de una extensión en un árbol de directorios, por ejemplo todos los .txt:

find . -type f -name "*.txt" -exec rm -f {} \;

Si prefieres que se te pida confirmación por cada archivo, puedes añadir -i a rm:

find . -type f -name "*.txt" -exec rm -i {} \;

Otra forma cómoda y algo más segura es usar -delete, que borra directamente lo que cumpla las condiciones de find, sin pasar por rm:

find . -type f -size 0 -delete

En el caso de directorios vacíos, puedes usar rmdir o también -delete:

find . -type d -empty -exec rmdir {} \;

find . -type d -empty -delete

Como norma general, cuando uses find para borrar cosas importantes, conviene probar primero el comando sin la parte de borrado (solo con los filtros) y revisar la lista de archivos afectados. Una vez claro que son los que quieres eliminar, añades la acción destructiva.

Combinar find con compresión, copias de seguridad y otras tareas

Gracias a la flexibilidad de -exec, find se integra perfectamente con herramientas de compresión y backup como tar, gzip o rsync. Por ejemplo, es habitual localizar ficheros antiguos y pesados y a continuación comprimirlos o archivarlos.

Un flujo típico podría ser: buscar archivos con más de 30 días de antigüedad y tamaño superior a 1 MB, comprimirlos y después eliminarlos si ya no son necesarios. A partir de ahí puedes diseñar scripts que se ejecuten con crontab para hacer limpieza y copias de seguridad de manera automática.

También resulta muy útil combinar find con tar para crear backups incrementales de archivos modificados recientemente, o generar listados de ficheros que luego se pasan a otras herramientas para informes, sincronización o validaciones.

En definitiva, el comando find es una pieza clave en el día a día de administradores de sistemas y desarrolladores, ya que les permite no solo localizar cualquier archivo en un sistema GNU/Linux, sino también actuar sobre él con una precisión quirúrgica, combinando múltiples criterios de filtrado, integrándolo con herramientas como grep, tar, xargs o rm y automatizando todo tipo de tareas rutinarias sin necesidad de interfaces gráficas ni búsquedas manuales interminables.