Untracked files verwijderen met git clean: veilig

TL;DR: om untracked files in git te verwijderen draai je git clean -fd — maar preview altijd eerst met git clean -nd, want clean verwijdert permanent en ze komen nooit in de prullenbak. Gebruik -f voor bestanden, -fd voor bestanden en mappen, en -fdx als gitignored build-output er ook aan moet geloven. De meest gehoorde klacht — git clean verwijdert mijn untracked files niet — betekent bijna altijd dat de bestanden in een untracked map zitten (voeg -d toe) of ignored files zijn (voeg -x toe). Untracked rommel is een normaal bijproduct van experimenten, builds en scripts naast je clone; deze gids laat zien hoe je elke verwijdering previewt, bestanden uit één map verwijdert, en welke combinaties je nooit draait in een repo waar je om geeft.

Wat betekent untracked files in git status?

Untracked betekent dat git het bestand op disk ziet maar nooit is verteld het te volgen — het zit niet in de index en heeft geen commit-history. git status groepeert alles in drie emmers:

$ git status --short
 M src/app.ts        # modified: tracked, changed
?? notes.txt         # untracked: new file git doesn't know
?? build/            # untracked directory: entirely new to git

Dat onderscheid telt omdat elke emmer een ander verwijdergereedschap nodig heeft. Bijgehouden-maar-gewijzigde bestanden draai je terug met git restore of commit je weg — git clean raakt ze niet aan. Alleen de ??-regels zijn git clean-territorium. Genegeerde bestanden (alles wat .gitignore matcht) zijn een verborgen vierde emmer: ze verschijnen niet eens als ??, en git clean slaat ze over tenzij je expliciet meedoet met -x.

Is je echte probleem een bijgehouden bestand dat nooit had gecommit moeten worden, dan is schoonmaken het verkeerde gereedschap — dat is een klus voor git rm --cached, of een reset van de laatste commit zoals behandeld in de laatste commit ongedaan maken, wijzigingen bewaren.

Hoe verwijder ik untracked files in git?

Het kerncommando is git clean -f. Zonder -f weigert git iets te verwijderen en print alleen een waarschuwing — een bewuste vangrail. De volledige routine ziet er zo uit:

# 1. See exactly what will be deleted (dry run — deletes nothing)
git clean -nd

# Would remove:
# notes.txt
# build/
# scratch/

# 2. Confirm nothing precious is in the list, then delete for real
git clean -fd

Flag voor flag:

• -f / --force — verplicht. Verwijdert daadwerkelijk untracked files.
• -d — recurseert in untracked mappen. Kale -f verwijdert alleen untracked files op het bovenste niveau en meldt de mappen die hij weigerde aan te raken.
• -n / --dry-run — toont wat er zou worden verwijderd. Draai dit altijd eerst.
• -x — verwijdert ook ignored files (node_modules, build-output, .env).
• -X — verwijdert alleen ignored files, en houdt untracked-maar-niet-ignored over.
• -i — interactieve modus; handig als de dry-run-lijst lang is.

Een gewoonte om over te nemen: behandel git clean -nd zoals git diff — je kijkt voordat je commit, je kijkt voordat je cleant.

Waarom verwijdert git clean mijn untracked files niet?

Drie echte oorzaken, op volgorde van hoe vaak ze bijten:

1. De bestanden zitten in een untracked map. Met alleen -f verwijdert git losse untracked files maar stopt bij mappen, en meldt zelfs Would remove build/ zonder het in een echte run te verwijderen. Voeg -d toe:

git clean -fd

2. De bestanden zijn gitignored. node_modules/, dist/, .venv/ — genegeerde paden zijn onzichtbaar voor een kale clean. De dry-run zal ze niet tonen, en de clean verwijdert ze ook niet. Doe expliciet mee:

git clean -fdx   # untracked + ignored files and directories

3. Een genest git-repository of submodule staat in de weg. Git verwijdert nooit de inhoud van een ander repo van buitenaf. Verwijder de submodule netjes of geef --force tweemaal mee (git clean -ffd), en geef de eerste optie de voorkeur.

Toont de dry-run niets maar blijft git status ??-regels geven, dan zit je waarschijnlijk in de verkeerde working tree — draai git rev-parse --show-toplevel en check of je in het repo zit dat je wilde schoonmaken.

Hoe verwijder ik untracked files uit alleen een specifieke map?

Beperk de clean door een pad mee te geven — de rest blijft onaangeroerd:

git clean -fd build/          # only inside build/
git clean -fd src/generated   # one specific tree

Dit is het antwoord op de wens om de untracked files en mappen in build/ weg te hebben maar je kladnotities in de repo-root te houden. Het pad is relatief aan je huidige map: draaiend vanuit de repo-root omvat het het hele repo, vanuit een submap alleen die subboom.

Hoe verwijder ik untracked files zonder ze te deleten?

Toont de dry-run bestanden die je misschien later wilt, gok dan niet — bewaar eerst, maak schoon daarna:

# Stash untracked files (including ignored ones with -a) without deleting
git stash push --include-untracked
git clean -fd                      # tree is clean
git stash pop                      # bring them back when needed

git stash -u haalt untracked files uit de boom maar houdt ze terug te halen — dat is de semantiek van verwijderen-zonder-deleten waar mensen eigenlijk naar zoeken. Voor een preview die je kunt houden geeft git clean -nd > clean-plan.txt de exacte lijst vóórdat je ergens toe besluit. Er is geen undo na git clean -f: verwijderd is weg.

git clean vs git rm vs git restore: welke wanneer?

Commando	Raakt aan	Verwijdert van disk	Gebruik wanneer
git clean -fd	Untracked files/mappen	Ja	Bestanden verwijderen die git nooit heeft bijgehouden
git clean -fdx	Untracked + ignored	Ja	Volledige reset inclusief node_modules, build-output
git rm <file>	Bijgehouden bestanden	Ja (gestaged)	Een bestand verwijderen en de verwijdering in git vastleggen
git rm --cached <file>	Bijgehouden bestanden	Nee	Stoppen met volgen, het bestand op disk houden
git restore <file>	Bijgehouden bestanden	Nee	Lokale bewerkingen weggooien, het bestand houden

De éénregelnorm: clean beheert wat git niet kent; rm en restore beheren wat git wel kent. Ze door elkaar halen is hoe mensen werk verliezen — git clean -fdx draaien in de overtuiging dat hij zich als git restore gedraagt.

Waarop moet je git clean nooit draaien?

Twee gewoontes om ronduit te vermijden:

1. Draai git clean -fdx nooit blind in een monorepo of workspace. Hij verwijdert elke genegeerde map — dat is elke node_modules, elke virtualenv, elke lokale .env in de boom. Terughalen kan een uur herinstalleren betekenen, en een verwijderde .env is misschien helemaal niet te herstellen.
2. Maak nooit een alias met force ingebakken. git config alias.wipe "clean -fd" voelt efficiënt tot je een typo in het pad maakt. Houd de dry-run één toetsaanslag weg (git clean -nd) en maak er een ritueel van twee commando’s: preview, dan verwijderen.

Ook goed om te weten: untracked files opruimen vlak voordat je een fork met upstream synchroniseert houdt het merge-oppervlak klein — een nette boom is de goedkoopste conflictverzekering die er is: fork met upstream synchroniseren, stap voor stap.

De veilige git clean-workflow, samengevat

git status --short        # what's in the tree?
git clean -nd             # preview: what WOULD go?
git clean -fd             # delete untracked files + directories
git clean -fdX            # (optional) clear only ignored build output
git status --short        # confirm: working tree clean

Preview, verwijder, verifieer — dertig seconden, nul spijt, en git status leest eindelijk weer schoon.