Ubuntu find e locate

"Onde eu salvei aquele arquivo?" O find (em inglês, "encontrar") responde essa pergunta. Ele percorre as pastas uma por uma e mostra tudo o que combina com o que você pediu: um nome, um tipo, um tamanho ou uma data. O locate faz algo parecido, mais rápido, mas com uma lista que pode estar desatualizada.

Você vai aprender

Como o find pensa: ponto de partida, testes e ação.
Buscar por nome, tipo, tamanho, data e dono.
Combinar testes com "e", "ou" e "não".
Fazer algo com o que foi encontrado: -exec e -delete.
Quando usar find, locate, ls -R | grep ou a busca do Arquivos.

Como o find pensa

Imagine que você entra numa pasta, abre cada gaveta, cada subpasta e cada arquivo, e pergunta: "este combina com o que procuro?". É exatamente o que o find faz. Todo comando find tem três partes:

Parte	Pergunta que responde	Exemplo
Ponto de partida	Onde começar a procurar?	`.` (aqui), `~` (pasta pessoal), `/etc`
Testes	O que conta como "achei"?	`-name "*.txt"`, `-type d`, `-size +10M`
Ação	O que fazer com cada achado?	Mostrar (padrão), `-exec`, `-delete`

find [ponto de partida] [testes] [ação]

Se você não informar a ação, o find só mostra o caminho de cada item encontrado. Se não informar o ponto de partida, ele começa na pasta atual.

Buscar pelo nome: `-name`

find: O programa que procura.
.: O ponto de partida: a pasta atual (e todas as subpastas dela).
-name: O teste: compara o nome de cada arquivo.
"*.txt": O padrão: qualquer nome que termine em .txt. As aspas são obrigatórias (veja abaixo).

$ find . -name "*.txt"
./Documentos/notas.txt
./frutas.txt

Cada linha é um caminho a partir do ponto de partida. ./frutas.txt está na própria pasta pessoal. ./Documentos/notas.txt está dentro de Documentos. O find entrou nas subpastas sozinho.

Por que as aspas?

Sem aspas, quem lê o * é o shell, antes do find. Se houver arquivos .jpg na pasta atual, o shell troca *.jpg pelos nomes deles, e o find recebe uma ordem sem sentido:

$ ls
foto1.jpg  foto2.jpg
$ find . -name *.jpg
find: os caminhos devem preceder a expressão: "foto2.jpg"
find: possível padrão sem aspas após o predicado "-name'?

O shell transformou o comando em find . -name foto1.jpg foto2.jpg. Com aspas, o * chega intacto ao find, que faz a comparação ele mesmo. Regra simples: sempre coloque o padrão entre aspas.

Ignorar maiúsculas: `-iname`

O -name diferencia maiúsculas de minúsculas: FOTO.JPG e foto.jpg são nomes diferentes. O -iname (de insensitive, "insensível") não diferencia:

$ find . -iname "*.JPG"
./Downloads/foto.jpg
./Imagens/ferias.jpg

Missão: encontre todos os arquivos .txt da pasta pessoal e salve a lista no arquivo lista.txt. Dica: find … > lista.txt. Confira com cat lista.txt.

Buscar pelo tipo: `-type`

Às vezes você quer só pastas, ou só arquivos. O teste -type filtra pelo tipo:

Valor	Tipo	Exemplo
`f`	Arquivo comum (file)	`find . -type f`
`d`	Pasta (directory)	`find . -type d`
`l`	Link simbólico (link)	`find . -type l`

$ find Documentos -type d
Documentos
Documentos/projetos
Documentos/projetos/site

Repare que o próprio ponto de partida, Documentos, aparece na lista: ele também é uma pasta.

Limitar a profundidade: `-maxdepth`

Por padrão o find desce em todas as subpastas. O -maxdepth (profundidade máxima) diz até onde ir: 1 é só a pasta atual, 2 inclui as subpastas, e assim por diante.

find .: Comece na pasta atual.
-maxdepth 1: Não entre em nenhuma subpasta.
-type f: Só arquivos comuns.

$ find . -maxdepth 1 -type f
./.bash_history
./.bashrc
./.profile
./frutas.txt

Diferente do ls, o find mostra os arquivos ocultos (os que começam com ponto) sem precisar de opção extra.

Coloque -maxdepth logo depois do ponto de partida

Ele vale para a busca toda, não só para o teste ao lado. Escrever primeiro deixa o comando mais fácil de ler.

Buscar pelo tamanho: `-size`

Disco cheio? Procure os arquivos grandes. O número leva uma letra de unidade e um sinal:

Escrita	Significado
`-size +10M`	Maior que 10 megabytes
`-size -100k`	Menor que 100 kilobytes
`-size +1G`	Maior que 1 gigabyte
`-size 0`	Exatamente zero (vazio)

Unidades: c = bytes, k = kilobytes, M = megabytes, G = gigabytes. Sem o sinal, o tamanho precisa ser exatamente aquele, o que quase nunca é o que você quer.

$ find Downloads -size +10M
Downloads/fotos-viagem.zip
Downloads/ubuntu-26.04-desktop-amd64.iso

Para ver o tamanho de cada um, junte com uma ação (veja -exec, mais abaixo).

Buscar pela data: `-mtime` e `-mmin`

-mtime conta em dias desde a última modificação (modification time); -mmin conta em minutos. O sinal muda o sentido:

Escrita	Significado	Uso típico
`-mtime -1`	Modificado nas últimas 24 horas	"O que eu mexi hoje?"
`-mtime +30`	Modificado há mais de 30 dias	Logs e backups antigos
`-mmin -10`	Modificado nos últimos 10 minutos	"Que arquivo esse programa acabou de criar?"

$ find ~/Documentos -mtime -1
/home/ana/Documentos/acesso.log
$ find /var/log -name "*.gz" -mtime +30
/var/log/syslog.4.gz
/var/log/auth.log.4.gz

A segunda busca mostra uma saída típica: arquivos de log compactados há mais de um mês. Os nomes mudam de máquina para máquina.

Outros testes úteis

Teste	O que encontra	Exemplo
`-empty`	Arquivos vazios e pastas vazias	`find . -empty`
`-user`	Arquivos de um dono	`find /tmp -user ana`
`-perm`	Arquivos com certa permissão	`find . -perm 777`
`-newer`	Mais novos que outro arquivo	`find . -newer notas.txt`
`-path`	Compara o caminho inteiro, não só o nome	`find . -path "/site/"`

Combinar testes: e, ou, não

Vários testes lado a lado precisam ser todos verdadeiros (um "e" implícito). Para "ou", use -o; para "não", use ! ou -not.

find .: Comece aqui.
$ -name "*.jpg" -o -name "*.png" $: Nome termina em .jpg ou .png. Os parênteses agrupam o "ou"; a barra invertida impede o shell de interpretá-los.
-size +1M: E maior que 1 MB.

$ find . \( -name "*.jpg" -o -name "*.png" \) -size +1M
./Imagens/ferias.jpg
$ find Documentos -type f ! -name "*.txt"
Documentos/acesso.log
Documentos/projetos/backup.sh
Documentos/projetos/site/index.html
Documentos/projetos/site/style.css
Documentos/relatorio.odt

A segunda busca pede arquivos que não terminam em .txt.

Fazer algo com o que foi encontrado

`-exec`: rodar um comando em cada achado

find . -name "*.sh": Encontre os scripts…
-exec: …e, para cada um, execute:
ls -l: o comando que você quiser…
{}: …onde {} é trocado pelo caminho do arquivo encontrado.
\;: Fim do comando. A barra impede o shell de usar o ;.

$ find . -name "*.sh" -exec ls -l {} \;
-rwxrwxr-x 1 ana ana 45 Oct 15 09:15 ./Documentos/projetos/backup.sh

Terminando com + em vez de \;, o find junta todos os achados e roda o comando uma vez só, o que é bem mais rápido com muitos arquivos:

$ find Downloads -size +10M -exec ls -lh {} +
-rw-rw-r-- 1 ana ana 100M Oct  1 19:30 Downloads/fotos-viagem.zip
-rw-rw-r-- 1 ana ana 5,9G Oct 10 21:14 Downloads/ubuntu-26.04-desktop-amd64.iso

`-delete`: apagar o que foi encontrado

Perigo: -delete não pede confirmação

Rode a busca sem -delete primeiro, leia a lista, e só então acrescente -delete no fim. Nunca coloque -delete antes dos testes: find . -delete -name "*.tmp" apaga tudo, porque a ação roda antes do teste.

$ find . -name "*.tmp"            # 1. confira a lista
./cache/a.tmp
./cache/b.tmp
$ find . -name "*.tmp" -delete    # 2. agora apague
$ find . -name "*.tmp"            # 3. confira de novo
$

Missão: a pasta logs tem arquivos vazios misturados com um que tem conteúdo. Apague só os vazios usando find com -empty e -delete. Antes de apagar, rode a busca sem -delete para conferir.

O que o find devolve

O find mostra um caminho por linha. Quando não encontra nada, não mostra nada e devolve 0: para ele, a busca correu bem, só não teve resultado. O código vira 1 quando há algum erro, como uma pasta sem permissão.

$ find . -name "*.mp4"
$ echo $?
0                                  « nada encontrado, mas sem erro
$ find /root -name "*.conf"
find: ‘/root’: Permissão negada
$ echo $?
1                                  « houve erro

Por isso, em scripts, não use o código do find para saber se algo foi achado. Conte as linhas: find . -name "*.mp4" | wc -l.

Formas diferentes de procurar arquivos

locate: busca instantânea numa lista pronta

O locate não percorre as pastas: ele consulta uma lista de todos os arquivos do sistema, atualizada uma vez por dia. Por isso é instantâneo, mas não acha arquivos criados depois da última atualização. No Ubuntu 26.04 ele não vem instalado; o pacote é o plocate:

$ locate notas
Comando 'locate' não encontrado, mas poder ser instalado com:
sudo apt install plocate                « o Ubuntu sugere o pacote
$ sudo apt install plocate
$ sudo updatedb                     # atualiza a lista agora
$ locate -i notas.txt
/home/ana/Documentos/notas.txt

Quando você digita um comando que não está instalado, o Ubuntu diz qual pacote o fornece. O "poder" no lugar de "pode" é um erro da tradução original.

locate: Busca na lista pronta.
-i: Ignora maiúsculas e minúsculas.
notas.txt: Um pedaço do caminho. Não precisa de *: qualquer caminho que contenha o texto aparece.

ls -R com grep

Funciona para uma olhada rápida, mas não mostra o caminho completo de cada arquivo:

$ ls -R | grep notas
notas.txt

Busca do aplicativo Arquivos

No desktop, abra o Arquivos, entre na pasta e pressione Ctrl+F. É ótimo para quem não lembra o nome exato e quer ver miniaturas.

Qual usar?

Ferramenta	Exemplo	Melhor quando…
`find`	`find ~ -name "*.pdf"`	Você precisa de filtros (tamanho, data, tipo) ou de agir sobre os achados.
`locate`	`locate -i contrato`	Você quer a resposta na hora, no sistema inteiro, e o arquivo não é de hoje.
`ls -R \| grep`	`ls -R \| grep foto`	Só quer saber se o nome existe, sem precisar do caminho.
Arquivos (`Ctrl`+`F`)	—	Prefere ver ícones e miniaturas.

Missão: descubra quais arquivos da pasta Downloads têm mais de 50 MB. Depois, use -exec ls -lh {} + para ver o tamanho de cada um.

Quando não funciona

"os caminhos devem preceder a expressão"

$ find . -name *.jpg
find: os caminhos devem preceder a expressão: "foto2.jpg"
find: possível padrão sem aspas após o predicado "-name'?

O que aconteceu: o padrão estava sem aspas e o shell trocou *.jpg pelos nomes dos arquivos da pasta atual.

Como resolver: coloque o padrão entre aspas: find . -name "*.jpg".

Uma enxurrada de "Permissão negada"

$ find /etc -name "hosts"
find: ‘/etc/credstore.encrypted’: Permissão negada
/etc/hosts
find: ‘/etc/ssl/private’: Permissão negada
find: ‘/etc/polkit-1/rules.d’: Permissão negada
find: ‘/etc/sssd’: Permissão negada
/etc/avahi/hosts
find: ‘/etc/credstore’: Permissão negada
find: ‘/etc/cups/ssl’: Permissão negada

O que aconteceu: o find tenta entrar em pastas do sistema que só o root pode ler. Os resultados úteis (/etc/hosts e /etc/avahi/hosts) ficam escondidos no meio dos erros. Procurando a partir de /, são centenas de linhas assim.

Como resolver: mande os erros para o "lixo" com 2>/dev/null (veja Redirecionamento):

$ find /etc -name "hosts" 2>/dev/null
/etc/hosts
/etc/avahi/hosts

Não apareceu nada, mas o arquivo existe

$ find . -name "Notas.txt"
$

O que aconteceu: o nome real é notas.txt, com n minúsculo. O -name diferencia maiúsculas. Outras causas comuns: começar a busca na pasta errada, ou digitar o nome inteiro quando só lembra um pedaço.

Como resolver: use -iname e curingas dos dois lados: find ~ -iname "*notas*".

"faltando argumento para -exec"

$ find . -name "*.sh" -exec ls -l {}
find: faltando argumento para "-exec"

O que aconteceu: faltou o \; (ou +) que fecha o comando do -exec.

Como resolver: find . -name "*.sh" -exec ls -l {} \;

"Argumento desconhecido para -type"

$ find . -type pasta
find: Argumento desconhecido para -type: pasta

Como resolver: o -type aceita só letras: f, d, l.

Referência de opções

find

Opção	Descrição	Exemplo
`-name`	Nome, com curingas; diferencia maiúsculas	`-name "*.log"`
`-iname`	Nome, sem diferenciar maiúsculas	`-iname "*.jpg"`
`-type`	`f` arquivo, `d` pasta, `l` link	`-type d`
`-size`	Tamanho: `+` maior, `-` menor; `c k M G`	`-size +100M`
`-mtime` / `-mmin`	Modificado há N dias / minutos	`-mtime -7`
`-maxdepth`	Profundidade máxima	`-maxdepth 2`
`-empty`	Arquivo ou pasta vazia	`-empty`
`-user`	Dono do arquivo	`-user ana`
`-perm`	Permissões	`-perm 644`
`-o` / `!`	"ou" / "não"	`! -name "*.txt"`
`-exec … {} \;`	Roda um comando para cada achado	`-exec ls -l {} \;`
`-exec … {} +`	Roda um comando com todos os achados juntos	`-exec ls -lh {} +`
`-delete`	Apaga os achados (sempre no fim!)	`-name "*.tmp" -delete`
`-print0`	Separa por caractere nulo, seguro para nomes com espaço	`-print0 \| xargs -0 …`

locate

Opção	Descrição	Exemplo
`-i`	Ignora maiúsculas	`locate -i readme`
`-c`	Só conta quantos resultados	`locate -c .jpg`
`-l N`	Mostra no máximo N resultados	`locate -l 5 .conf`
`sudo updatedb`	Atualiza a lista do locate	`sudo updatedb`

Exercícios

1. Só pastas

Complete para listar apenas as pastas dentro de Documentos:

find Documentos -type

2. Arquivos grandes

Complete para encontrar arquivos maiores que 500 MB na pasta pessoal:

find ~ -size

3. Sem diferenciar maiúsculas

Complete para achar Relatorio.PDF, relatorio.pdf e variações:

find ~ "relatorio.pdf"

4. find . -name "*.mp4" não mostrou nada. O que echo $? mostra logo depois?

1, porque não achou nada. 0, porque a busca rodou sem erros. 127, porque o comando não existe. Uma mensagem de erro.

5. Qual comando é perigoso e pode apagar tudo na pasta?

find . -name "*.tmp" find . -name "*.tmp" -delete find . -name "*.tmp" -exec ls {} \; find . -delete -name "*.tmp"

Resumo

find [onde] [testes] [ação]: sem ação, ele só mostra os caminhos.
Sempre coloque o padrão de -name entre aspas.
Filtros principais: -name, -iname, -type, -size, -mtime, -maxdepth.
-exec cmd {} \; roda um comando por achado; {} + roda uma vez com todos.
Confira a lista antes de usar -delete, e ponha -delete sempre no fim.
2>/dev/null esconde os erros de permissão.
locate (pacote plocate) é instantâneo, mas usa uma lista atualizada uma vez por dia.