Buscar archivos: find y locate

1. Qué herramienta para qué búsqueda

«Buscar» abarca tareas distintas, y ya tenemos herramientas para algunas. Conviene ubicar las nuevas en relación con las que conocemos:

La diferencia entre los comodines y find es de alcance. Un comodín mira un nivel: *.txt son los archivos de texto de este directorio. find baja por todos los subdirectorios, hasta el fondo, y además puede preguntar por propiedades que un nombre no revela, como el tamaño o la fecha.

2. find: dónde, qué y qué hacer

En el tema 3 pusimos a find entre los comandos que no siguen la gramática habitual. Su línea tiene tres partes, siempre en este orden:

find /var/log -name "*.log" -mtime -7 -print
     │        │             │         │
     │        │             │         └─ acción: qué hacer con cada resultado
     │        │             └─ condición: modificado en los últimos 7 días
     │        └─ condición: el nombre termina en .log
     └─ dónde empezar a buscar

Las condiciones y las acciones son palabras completas precedidas de un solo guion: -name, no --name. Es la rareza de find, y hay que aceptarla.

Sin condiciones, find muestra todo lo que hay a partir del punto de partida. Es un listado recursivo con una ruta por línea:

$ cd ~/practica
$ find                              # equivale a: find . -print
.
./notas.txt
./fotos
./informe.txt
$ find ~/practica
/home/ana/practica
/home/ana/practica/notas.txt
/home/ana/practica/fotos
/home/ana/practica/informe.txt

Tres detalles de esa salida valen para todo el tema. El punto de partida forma parte de los resultados: por eso aparece el propio directorio. Las rutas se muestran con la misma forma que el punto de partida: relativas si escribiste ., absolutas si escribiste una ruta absoluta. Y el orden no es alfabético, sino el orden interno del directorio.

3. Buscar por nombre

La condición más usada es -name, que compara el nombre de cada archivo con un patrón de comodines, los mismos del tema 9:

$ find . -name "*.txt"
./notas.txt
./informe.txt
$ find . -name "notas.txt"
./notas.txt
$ find . -name "notas"              # nada: ningún archivo se llama exactamente así
$ find . -iname "NOTAS*"            # sin distinguir mayúsculas
./notas.txt

Hay dos reglas, y las dos son fuente de errores:

La segunda: -name compara el nombre completo, no una parte. -name "notas" no encuentra notas.txt. Para buscar «lo que contiene» hay que decirlo con asteriscos: -name "*notas*".

Con un punto de partida más grande se ve para qué sirve. Buscar todo lo que se llama README en la documentación instalada, sin importar en qué subdirectorio esté:

$ find /usr/share/doc -name "README*"
/usr/share/doc/sudo/README.Debian
/usr/share/doc/bash/README.gz
/usr/share/doc/tar/README.Debian
…

4. Buscar por tipo

-type selecciona según la clase de objeto, con las mismas letras que muestra el primer carácter de ls -l (tema 7), salvo una:

$ find . -type d
.
./fotos
$ find . -type f
./notas.txt
./informe.txt

Casi siempre conviene incluirla. Cuando se busca «archivos de más de cien megabytes» o «lo modificado hoy», lo que interesa son archivos, y sin -type f aparecen también los directorios que cumplen la condición.

5. Buscar por tamaño

-size compara el tamaño con un número seguido de una unidad. El signo delante del número cambia el sentido de la comparación, y esa convención se repite en otras condiciones de find:

$ find . -type f -size +10k
./informe.txt
$ find . -type f -size -100c
./notas.txt
$ find . -empty                     # archivos de tamaño cero y directorios sin contenido
./fotos

Las letras distinguen mayúsculas: k minúscula, M y G mayúsculas. Y hay una trampa con el redondeo. find redondea cada tamaño hacia arriba a la unidad indicada antes de comparar, de modo que un archivo de un solo byte cuenta como «1M» cuando la unidad es el megabyte. Por eso -size -1M no encuentra «lo que pesa menos de un megabyte», sino únicamente los archivos vacíos. Para los tamaños chicos conviene usar una unidad menor: -size -1024k.

El uso clásico de esta condición es averiguar qué ocupa el disco:

$ find ~ -type f -size +100M        # los archivos grandes de mi directorio personal

6. Buscar por fecha

Las condiciones de fecha miden cuánto tiempo pasó desde la última modificación, con la misma convención de signos:

El signo es lo que más confunde, porque se lee al revés de lo que sugiere la intuición: el menos es lo reciente, porque pasó menos tiempo; el más es lo viejo.

$ find . -type f -mtime -1          # modificado en las últimas 24 horas
./notas.txt
./informe.txt
$ find . -newer notas.txt           # modificado después que notas.txt
.
./fotos
./informe.txt

Los días de -mtime son períodos de 24 horas contados desde este momento, no días del calendario. -newer evita las cuentas: compara con la fecha de otro archivo, y sirve para responder «¿qué cambió desde que hice tal cosa?».

Las mismas condiciones existen para las otras fechas del tema 7, cambiando la primera letra: -atime y -amin para el último acceso, -ctime y -cmin para el último cambio de estado. Dos usos reales:

$ find /etc -type f -mtime -2       # qué configuración cambió en los últimos dos días
$ find /var/log -name "*.gz" -mtime +90   # registros comprimidos de más de tres meses

7. Buscar por dueño y permisos

Las demás columnas del listado largo también se pueden consultar. Las mencionamos aquí para tener el cuadro completo; cobran sentido en el bloque 4:

$ find /tmp -user ana               # lo que dejé en el directorio temporal
/tmp/prueba
/tmp/prueba/notas.txt
…

8. Combinar condiciones

La potencia de find está en combinar. Cuando se escriben varias condiciones seguidas, un archivo debe cumplirlas todas: entre ellas hay un «y» implícito. Varias ya aparecieron así. Para las otras combinaciones hay operadores:

$ find . -name "*.txt" -size +10k   # .txt Y de más de 10 KB
./informe.txt
$ find . ! -name "*.txt"            # lo que NO es .txt
.
./fotos
$ find . -name "notas*" -o -name "fotos"   # un nombre O el otro
./notas.txt
./fotos

Los paréntesis hacen falta cuando se mezclan «y» con «o», porque el «y» se resuelve primero, igual que la multiplicación antes que la suma. Deben escribirse con una barra invertida delante y con espacios alrededor: el paréntesis es un carácter especial para la shell, como vimos en el tema anterior, y hay que protegerlo para que llegue a find.

$ find ~ \( -iname "*.jpg" -o -iname "*.png" \) -size +1M

Sin los paréntesis, la condición de tamaño se aplicaría solo a los .png, y aparecerían todos los .jpg, de cualquier tamaño.

9. Limitar la profundidad

Por defecto, find baja hasta el último subdirectorio. Dos opciones acotan el recorrido:

$ find /etc -maxdepth 1 -name "host*"
/etc/hostname
/etc/hosts
/etc/host.conf
$ find ~ -maxdepth 1 -type d ! -name ".*"   # mis directorios visibles, sin entrar en ellos

Con -maxdepth 1, find se convierte en un ls con filtros: mira un solo directorio, pero puede seleccionar por tamaño, fecha o tipo, cosa que los comodines no saben hacer. Estas dos opciones deben escribirse antes que las condiciones; si no, find emite una advertencia.

Para dejar fuera una rama del árbol, lo más simple es negar una condición de ruta: find . ! -path "./fotos/*" recorre todo salvo el contenido de fotos.

10. Los errores de permisos

Al buscar fuera del directorio personal, find tropieza con directorios en los que un usuario común no puede entrar, y lo informa:

$ find /etc -name "hostname"
find: ‘/etc/polkit-1/rules.d’: Permission denied
/etc/hostname
find: ‘/etc/ssl/private’: Permission denied

No es una falla. find encontró lo que pudo y avisa de los lugares que no pudo revisar. En una búsqueda sobre /, sin embargo, los avisos son cientos y tapan los resultados. Se los puede descartar así:

$ find /etc -name "hostname" 2>/dev/null
/etc/hostname

Es un anticipo del bloque 5. Los programas escriben sus resultados y sus mensajes de error por dos canales separados; en la pantalla se mezclan, pero se los puede dirigir a lugares distintos. 2> significa «el canal de errores, a…», y el destino es /dev/null, el sumidero del tema 8. Los resultados siguen llegando a la pantalla.

Un consejo de eficiencia: cuanto más preciso el punto de partida, mejor. Buscar un archivo de configuración en /etc lleva una fracción de segundo; buscarlo en / obliga a recorrer el disco entero, incluidos /proc y /sys, que no contienen archivos reales. El mapa del tema 8 sirve para eso.

11. Las acciones: mostrar y borrar

Hasta aquí usamos la acción por defecto, -print. Hay otras:

$ find . -type f -ls
  1311452      4 -rw-rw-r--   1 ana      ana            18 oct 12 10:32 ./notas.txt
  1311460     16 -rw-rw-r--   1 ana      ana         12813 oct 12 10:41 ./informe.txt

Las dos primeras columnas son el número de inodo y el espacio ocupado en disco, en kilobytes; el resto es el listado largo conocido.

-delete es la acción que exige respeto. Borra sin preguntar y sin papelera, todo lo que las condiciones seleccionen. Tiene además una particularidad que ha causado desastres: find evalúa su línea de izquierda a derecha, y la acción se aplica en el lugar donde está escrita.

12. -exec: un comando sobre cada resultado

La acción más versátil es -exec, que ejecuta cualquier comando sobre lo encontrado. Así find deja de ser un buscador para convertirse en una forma de aplicar una operación a una selección de archivos.

find . -name "*.txt" -exec ls -lh {} \;
                     │     │      │  │
                     │     │      │  └─ fin del comando
                     │     │      └─ aquí se pone la ruta de cada resultado
                     │     └─ el comando, con sus opciones
                     └─ la acción

Las llaves {} marcan el lugar donde find escribe la ruta encontrada. El comando debe tener un final explícito, y hay dos terminadores, con efectos distintos:

Con echo, la lente del tema anterior, la diferencia se ve:

$ find . -name "*.txt" -exec echo Encontré: {} \;
Encontré: ./notas.txt
Encontré: ./informe.txt
$ find . -name "*.txt" -exec echo Encontré: {} +
Encontré: ./notas.txt ./informe.txt
$ find . -name "*.txt" -exec ls -lh {} +
-rw-rw-r-- 1 ana ana 13K oct 12 10:41 ./informe.txt
-rw-rw-r-- 1 ana ana  18 oct 12 10:32 ./notas.txt

La forma con + es más rápida, porque arranca un solo proceso en lugar de miles, y es la preferible siempre que el comando acepte varios archivos. La forma con \; queda para los comandos que trabajan con uno por vez. El punto y coma lleva una barra invertida por la razón de siempre: para la shell es un carácter especial, y hay que protegerlo para que llegue a find.

-exec resuelve dos problemas que dejamos pendientes en el tema 9. Uno es el error Argument list too long: con +, find reparte los archivos en varias ejecuciones si no entran en una. El otro son los nombres con espacios: cada ruta se entrega al comando como un argumento entero, sin pasar por la shell, y no se parte.

Cuando el comando modifica o borra, hay una variante prudente: -ok funciona igual que -exec con \;, pero muestra cada comando y espera una confirmación antes de ejecutarlo.

$ find . -name "*.txt" -ok rm {} \;
< rm ... ./notas.txt > ? n
< rm ... ./informe.txt > ? n

13. locate: la búsqueda instantánea

find recorre el disco en el momento, y sobre un árbol grande eso lleva segundos o minutos. locate usa otro método: consulta un índice, una base de datos con las rutas de todos los archivos del sistema, preparada de antemano. Responde al instante.

En Ubuntu hay que instalarlo. El paquete actual se llama plocate:

$ sudo apt install plocate
$ locate os-release
/etc/os-release
/usr/lib/os-release

El argumento no es un patrón sino un fragmento de texto: locate muestra todas las rutas que lo contienen, en cualquier parte, incluidos los nombres de los directorios. Por eso una palabra corta devuelve cientos de líneas, y conviene acotar:

La velocidad tiene un precio: el índice es una foto, y puede estar desactualizada. El sistema lo reconstruye una vez por día. Un archivo creado después no aparece, y uno borrado puede seguir figurando.

$ locate practica/notas             # creado hoy: el índice todavía no lo conoce
$ sudo updatedb                     # reconstruir el índice ahora
$ locate practica/notas
/home/ana/practica/notas.txt

El índice tampoco incluye todo: deja fuera, entre otros, /tmp y los discos externos. La comparación completa:

Se complementan. locate es para la pregunta rápida «¿dónde hay algo que se llame así?». find es para todo lo demás, y es el que está garantizado en cualquier sistema.

14. Recetas

Las búsquedas reales combinan lo visto. Estas son las que más se repiten; conviene leer cada una reconociendo sus partes: dónde, condiciones y acción.

La séptima usa una tubería hacia wc -l, que cuenta líneas: como find escribe una ruta por línea, el resultado es la cantidad de archivos. Es el patrón de trabajo que domina desde el bloque 5: un comando produce una lista y otro la procesa.

Con este tema termina el segundo bloque. Sabes orientarte en el árbol, moverte por él, leer lo que hay en cada directorio, nombrar grupos de archivos y encontrar cualquier cosa. Todo eso fue mirar. En el tema 11 empezamos a modificar: crear, copiar, mover y borrar.

15. Resumen

• find recorre un árbol de directorios completo y selecciona archivos por sus propiedades. Su línea tiene tres partes: dónde, condiciones y acción.
• Sin condiciones selecciona todo; sin acción, muestra la ruta de cada resultado.
• -name compara el nombre completo con un patrón, que debe ir entre comillas. -iname no distingue mayúsculas.
• -type f selecciona archivos, -type d directorios y -type l enlaces simbólicos.
• -size compara el tamaño: +N es más de N y -N es menos, con las unidades c, k, M y G.
• -mtime y -mmin comparan la antigüedad en días y en minutos. El signo menos selecciona lo reciente; el más, lo viejo.
• Varias condiciones seguidas deben cumplirse todas. -o es «o», ! es «no», y \( \) agrupa.
• -maxdepth limita cuántos niveles se recorren.
• Los avisos Permission denied se descartan con 2>/dev/null.
• -delete borra los resultados y debe ir siempre al final de la línea, después de comprobar la búsqueda.
• -exec comando {} + ejecuta un comando con todos los resultados; con \;, una vez por cada uno. -ok pide confirmación.
• locate busca al instante en un índice de rutas, que se actualiza una vez por día o con sudo updatedb.

16. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Encuentra todos los archivos de /etc cuyo nombre termina en .conf, y cuenta cuántos son con | wc -l. Repite con 2>/dev/null y compara lo que ves.
2. Lista los directorios que están directamente dentro de /usr, sin entrar en ellos, usando find.
3. Encuentra los cinco archivos más grandes de /usr/bin: busca los de más de 5 MB y muéstralos con -exec ls -lhS {} +.
4. Averigua qué archivos de tu directorio personal se modificaron en los últimos diez minutos. Ejecuta antes algún comando, para que el historial tenga algo que guardar al cerrar la terminal.
5. Busca en /usr/share los archivos cuyo nombre contenga bash, sin distinguir mayúsculas.
6. Encuentra en ~/practica todo lo que no sea un archivo común.
7. En /tmp, crea un directorio de prueba con varios archivos .tmp y .txt usando las llaves del tema 9. Borra solo los .tmp con find: primero la búsqueda sola, después con -delete.
8. Compara la salida de find ~/practica -name "*.txt" -exec echo {} \; con la misma línea terminada en +.
9. Instala plocate, ejecuta locate -c bin y locate -b -c bin, y explica la diferencia entre los dos números.
10. Busca con find los enlaces simbólicos que hay directamente en / y comprueba el resultado con ls -l /.