Linux commando: find

Je weet dat een bestand ergens op de server staat. Misschien is het een configuratiebestand dat gisteravond is gewijzigd, een enorm logbestand dat de schijf vult, of alle .jpg bestanden die drie mappen diep zijn weggestopt. Het zou een uur duren om alle mappen door te klikken. Eén commando doorzoekt de hele boomstructuur voor je en vindt ze allemaal binnen enkele seconden, op naam, op grootte, op ouderdom, op wat dan ook: find.

2. Waar komt de naam vandaan?

Anders dan zijn cryptische buren grep, awk en sed, is de naam find geen acroniem of binnenpretje. Het is gewoon het gewone Engelse werkwoord voor "vinden". De vroege Unix-auteurs, die van korte namen hielden, konden deze niet veel korter maken, dus lieten ze het als het gewone woord voor de gewone taak: dingen vinden.

Er is toch een kleine kanttekening die het weten waard is. De naam suggereert dat het gereedschap bestanden alleen opzoekt, maar dat doet het tekort. Vanaf het prille begin kon find ook een commando op elke match uitvoeren. Een betere manier om de naam te lezen is dus "vind elk bestand dat past, en doe hier dan dit mee". In die tweede helft zit het meeste van zijn kracht.

Lees het commando als een zin: find WAAR WAT-TE-MATCHEN WAT-TE-DOEN. Begin hier, match bestanden zo, doe er dan zo iets mee. Zodra je die vorm ziet, wordt elk find-commando makkelijk te lezen.

4. Eenvoudige toepassingen

4.1 Het eenvoudigste gebruik

Geef find een startmap en verder niets. Het toont elk bestand en elke map eronder, een volledig pad per regel:

$ find /etc/ssh
/etc/ssh
/etc/ssh/sshd_config
/etc/ssh/ssh_config
/etc/ssh/ssh_host_rsa_key

Bij GNU find mag je het pad zelfs weglaten, en dan zoekt het standaard in de huidige map .:

$ find
.
./notes.txt
./sub
./sub/report.pdf

Deze kale lijst is al nuttig, maar het punt van find is om die met een test te versmallen.

4.2 Zoeken op naam

De test -name toetst de naam van het bestand aan een patroon. Het patroon gebruikt shell-jokertekens (* voor willekeurige tekens, ? voor een enkel teken), geen reguliere expressies. Zet het patroon altijd tussen aanhalingstekens zodat de shell het onaangeroerd aan find doorgeeft:

$ find /var/www -name "*.php"
/var/www/index.php
/var/www/admin/login.php

Om hoofdletters te negeren, gebruik je -iname (kort voor insensitive name). Dit is de versie die je pakt als je niet zeker weet hoe een bestand met hoofdletters is geschreven:

$ find . -iname "readme*"
./README.md
./docs/readme.txt

4.3 Zoeken op type

De test -type beperkt de resultaten tot een soort item. De twee die je het meest gebruikt zijn f voor een gewoon bestand (file) en d voor een map (directory):

$ find /var/log -type f -name "*.log"
/var/log/syslog
/var/log/nginx/access.log

Hier zorgt -type f ervoor dat een map die toevallig iets.log heet, er niet bij zit. De volledige lijst met typeletters:

4.4 Beperk hoe diep je zoekt

Standaard daalt find de hele boomstructuur af, hoe diep die ook gaat. De optie -maxdepth (kort voor maximum depth) stopt het na een ingesteld aantal niveaus. De startmap is diepte 0, de directe inhoud is diepte 1, enzovoort:

$ find . -maxdepth 1 -type f
./notes.txt
./config.yml

Dit toont alleen de bestanden in de huidige map, zonder in submappen te duiken. Zijn partner -mindepth (kort voor minimum depth) doet het tegenovergestelde en slaat de ondiepe niveaus over. Zet deze opties voor de tests; GNU find waarschuwt als ze later komen.

6. Geavanceerde toepassingen

6.1 Een commando op elke match uitvoeren met -exec

De echte kracht van find is -exec, dat een commando uitvoert op elk bestand dat het vindt. Binnen het commando staat de plaatshouder {} voor het huidige bestand, en het commando eindigt met een geescapete puntkomma \;:

$ find . -name "*.tmp" -exec rm {} \;

Dit voert rm een keer uit voor elk .tmp-bestand. Dat werkt, maar per bestand een nieuw proces starten is traag als het er duizenden zijn. De +-vorm lost dit op: het verzamelt zoveel bestanden als er passen en geeft ze aan een enkel commando, precies zoals xargs doet:

$ find . -name "*.tmp" -exec rm {} +     # one rm for many files, much faster

Gebruik \; als het commando de bestanden een voor een moet zien, en + als het commando een lijst accepteert en je snelheid wilt. Er is ook -execdir, dat het commando uitvoert vanuit de eigen map van elk bestand. Dat is veiliger tegen streken van rare padnamen, en het is de betere keuze in scripts.

6.2 Bevestig voor je iets doet, en verwijder veilig

Voor gevaarlijke acties werkt -ok als -exec, maar het vraagt je om elk bestand te bevestigen voordat het draait:

$ find . -name "*.bak" -ok rm {} \;
< rm ... ./old.bak > ?

GNU find heeft ook een ingebouwde -delete die matches verwijdert zonder ook maar rm te starten. Het is handig maar onverbiddelijk, dus bouw het commando eerst als een zoekopdracht, bekijk de uitvoer, en wissel pas dan -print voor -delete:

$ find . -name "*.tmp" -print      # LOOK first
$ find . -name "*.tmp" -delete     # then delete, once you trust the list

6.3 De veilige pijp: -print0 en xargs -0

find in een ander gereedschap pijpen is gangbaar, maar een gewone pijp splitst op spaties en regeleindes, dus een bestand met de naam my report.pdf breekt in tweeen. De oplossing is het nulgescheiden paar: -print0 eindigt elk resultaat met een onzichtbare nulbyte in plaats van een regeleinde, en xargs -0 leest datzelfde scheidingsteken:

$ find . -name "*.log" -print0 | xargs -0 gzip

Geen enkele bestandsnaam kan een nulbyte bevatten, dus dit verwerkt spaties, aanhalingstekens en regeleindes zonder een enkele verrassing. Maak het je standaard telkens als find een ander commando via een pijp voedt.

6.4 Snoeien: hele takken overslaan

Soms wil je dat find een hele map vermijdt, zoals .git of node_modules, zodat het geen tijd verspilt door erin te lopen. De actie -prune vertelt find "daal hier niet in af". Het patroon leest eerst wat vreemd maar is het onthouden waard:

$ find . -path "*/node_modules" -prune -o -name "*.js" -print
./src/app.js
./src/util.js

Lees het als: als het pad een node_modules-map is, snoei die (sla de inhoud over); anders, als de naam op .js eindigt, toon die. De expliciete -print aan het eind is hier nodig, want zodra je een actie zoals -prune gebruikt, toont find niet langer automatisch.

6.5 Matchen met echte reguliere expressies

Als shell-jokertekens niet genoeg zijn, toetst -regex het hele pad aan een reguliere expressie. Let op dat het het volledige pad toetst, niet alleen de naam, dus houd rekening met de voorafgaande mappen:

$ find . -regextype posix-extended -regex ".*/[0-9]{4}-[0-9]{2}-[0-9]{2}\.log"
./logs/2026-07-11.log

De optie -regextype kiest het dialect; posix-extended gedraagt zich als grep -E. Dit is een GNU-functie, dus vermijd het in scripts die ook op macOS of BSD moeten draaien.

6.6 Hoe find met symbolische links omgaat

Standaard kijkt find naar de symbolische link zelf, niet naar het bestand waar die naar wijst, en het loopt nooit door een link heen een andere map in. Drie opties, geplaatst voor het pad, veranderen dit:

$ find -L /var/www -name "*.php"     # follow links into shared folders too

Omdat -type l een link matcht door naar de link zelf te kijken, kan het niet zien of het doel nog bestaat. Gebruik daarvoor -xtype l (kort voor het type na het volgen van de link), dat links meldt waarvan het doel ontbreekt. Het is de snelle manier om kapotte symlinks op te sporen nadat bestanden zijn verplaatst of verwijderd:

$ find /var/www -xtype l
/var/www/current
/var/www/logs/latest.log

8. Beste werkwijzen

• Zet naampatronen altijd tussen aanhalingstekens. Schrijf -name "*.log", niet -name *.log, anders vult de shell de * in voordat find die ooit ziet.
• Zet de goedkoopste test eerst. Begin met -name of -type zodat dure tests en -exec alleen draaien op bestanden die al matchten.
• Bekijk eerst voordat je iets doet. Bouw het commando met -print, controleer de lijst, en verander het pas dan in -delete of -exec rm.
• Geef de voorkeur aan -exec ... + boven -exec ... \; als het commando veel bestanden accepteert. Het draait veel minder processen en is veel sneller.
• Gebruik -print0 | xargs -0 in pijpen. Het is de enige manier om bestandsnamen met spaties of regeleindes veilig te verwerken.
• Beperk de diepte op grote bomen. -maxdepth en -prune voorkomen dat een zoektocht afdwaalt naar .git, node_modules of een aangekoppelde netwerkschijf.
• Gebruik -quit om bij de eerste treffer te stoppen. Als je alleen hoeft te weten of er uberhaupt een match bestaat, laat -quit find stoppen zodra het er een vindt, in plaats van de hele boomstructuur af te lopen.
• Voeg -type f toe als je bestanden bedoelt. Het voorkomt dat mappen en rare items binnensluipen in een resultaat dat je wilt verwijderen of wijzigen.

Als je alle details nodig hebt, is de documentatie een commando ver weg:

$ man find        # the full manual page
$ find --help     # a quick summary of every test and action
$ info find       # the long GNU manual with examples

10. Samenvatting

Het commando find is hoe je bestanden op een Linux-systeem opspoort op elke eigenschap die ze hebben, en er dan in een stap iets mee doet.

• find loopt een boomstructuur af en toetst elk item aan een beschrijving: naam, type, grootte, leeftijd, eigenaar of permissies.
• De naam is het gewone Engelse werkwoord, maar het doet meer dan opzoeken: het kan elk commando op elke match uitvoeren.
• Het mentale model is een expressie die luidt find WAAR WAT-TE-MATCHEN WAT-TE-DOEN, bestand voor bestand geevalueerd.
• Alledaagse tests: -name/-iname (op naam), -type f of -type d (op soort), -size (op bytes), -mtime/-mmin (op leeftijd).
• Tests verbinden met een impliciete "en"; gebruik -o, ! en \( \) om rijkere voorwaarden te bouwen.
• -exec {} + voert snel een commando op de matches uit, en -print0 | xargs -0 pijpt ze veilig.
• Zet je tests op volgorde van goedkoopst-eerst voor snelheid, en bekijk altijd eerst met -print voordat je -delete gebruikt.
• Bij twijfel typ je man find of find --help.

Dit is de handige naslag om te bewaren:

find . -name "*.log"            files named *.log, from here down
find . -iname "readme*"         same, ignoring upper/lower case
find /var -type f -size +100M   regular files larger than 100 MB
find /etc -mtime -1             changed in the last day
find . -mmin -30                changed in the last 30 minutes
find . -type d -empty           empty directories
find . -maxdepth 1 -type f      files in this folder only, no descending
find . \( -name "*.jpg" -o -name "*.png" \)   match either pattern
find . -name "*.tmp" -delete    delete matches (preview with -print first)
find . -name "*.tmp" -exec rm {} +            run one rm for many files
find . -name "*.log" -print0 | xargs -0 gzip  safe pipe for odd names
find . -path "*/.git" -prune -o -name "*.py" -print   skip a whole folder
find . -name "*.conf" -exec grep -l "debug" {} +      find + grep together

Zodra find natuurlijk aanvoelt, houdt een Linux-server op dingen voor je te verbergen. Je kunt het bestand opsporen dat vannacht is gewijzigd, de rommel opruimen die een schijf volzet, en elk bijpassend bestand in een enorme boomstructuur met een enkele regel bereiken. Als jouw servers bestanden bevatten die iemand op schaal moet opsporen, opruimen of bewerken, is dat precies het soort werk waar ik bij help.