Bestanden verwijderen uit Git-repositories zonder je project te breken

Bestanden verwijderen in Git is niet altijd zo simpel als het lijkt. Je verwijdert een bestand van je systeem, maar dat betekent niet dat het ook uit de repository weg is. Het kan nog steeds in je geschiedenis staan of, erger nog, per ongeluk gecommit worden, zoals een config-bestand of een API-sleutel.

In deze gids leer je hoe je bestanden uit Git verwijdert. We beginnen met basiscommando’s zoals git rm en gaan daarna in op geavanceerdere methoden, zoals het opschonen van niet-getrackte bestanden en het bewerken van je commithistorie.

Vereisten

Voordat we bestanden met Git verwijderen, zorgen we dat alles goed is ingesteld.

Controleer eerst of Git is geïnstalleerd. Open je terminal en voer uit:

git --version

Zie je een versienummer, dan ben je klaar om te gaan. 

Zie je een versienummer, dan ben je klaar om te gaan.

Je kunt ook een Git-GUI installeren zoals GitHub Desktop, Sourcetree of GitKraken als je liever visueel werkt. Maar in deze gids gebruik ik de command line (Git Bash).

Zorg dat je toestemming hebt om wijzigingen aan te brengen in de repository, zeker als je deel uitmaakt van een team of werkt met een remote repo zoals GitHub of GitLab.

Let op: Sommige verwijderacties zijn niet ongedaan te maken. Het is dus slim om een back-up van je project te maken of in elk geval de staat van je repo dubbel te checken voordat je commando’s uitvoert die bestanden verwijderen.

Klaar? Laten we beginnen.

Basisbestanden verwijderen in Git

Er zijn verschillende manieren om bestanden in Git te verwijderen, afhankelijk van wat je wilt doen. Dit zijn veelvoorkomende opties:

Met git rm

Het git rm-commando verwijdert bestanden uit je Git-repository. Als je het uitvoert, gebeuren er twee dingen:

• Git verwijdert het bestand uit je working directory
• Het staged die wijziging voor de volgende commit

Maar Git verwijdert het bestand niet alleen. Het legt de verwijdering vast in je geschiedenis. Zodra je commit, is het bestand officieel uit het project verwijderd.

git rm file1.txt

Je kunt één bestand verwijderen, meerdere bestanden, of een groep bestanden met wildcards. 

Bijvoorbeeld, om alle logbestanden te verwijderen:

git rm *.log

Dit zegt tegen Git dat elk bestand in de map dat eindigt op .log verwijderd moet worden. Je kunt de wijziging bevestigen met:

git status

Meerdere bestanden verwijderen met één git rm-commando. Afbeelding door auteur.

Alle bestanden in een map verwijderen maar de map zelf behouden? Gebruik:

git rm temp/*

Dit verwijdert alle bestanden in de temp-map zonder de map zelf te verwijderen.

Git voegt ook veiligheidschecks toe. Als een bestand onopgeslagen wijzigingen heeft, verwijdert Git het niet tenzij je forceert. Gebruik dit dus alleen als je zeker weet dat die wijzigingen weg kunnen:

git rm -f

Om een hele map en alles erin te verwijderen, voeg je de -r-vlag toe:

git rm -r testfolder

Dit verwijdert testfolder en alle bestanden erin.

Nu, om de wijziging te committen, voer je het volgende commando uit:

git commit -m "removed log files”

Belangrijke opties voor git rm

Dit zijn de meest gebruikte opties bij git rm:

1. <bestandsnaam>

Dit is de basis. Som de bestanden op die je wilt verwijderen:

git rm file1.txt file2.txt

Je kunt ook een wildcard gebruiken om meerdere bestanden van hetzelfde type te verwijderen. Bijvoorbeeld om alle .txt-bestanden te verwijderen:

git rm *.txt

(Hier betekent * alles. Het matcht elke bestandsnaam die eindigt op .txt.)

2. --cached

Dit verwijdert het bestand uit de repository maar laat het op je computer staan. Stel dat ik per ongeluk een gevoelig bestand zoals config.env heb toegevoegd. Ik wil het niet in de repo, maar ik heb het lokaal nog wel nodig. Dan voer ik uit:

git rm --cached config.env

Hier verwijdert git rm het uit de repository en working directory. En --cached haalt het uit tracking door Git (zodat het niet wordt gepusht), maar laat het fysiek staan.

Voeg het toe aan .gitignore om te voorkomen dat het opnieuw wordt toegevoegd:

echo config.env >> .gitignore

3. -r

Staat voor recursive. In plaats van één bestand verwijdert dit recursief de map en de inhoud. Zonder deze vlag krijg je een fout als je een map probeert te verwijderen.

git rm -r <folder-name>

Hier heb ik een map testfolder gemaakt met twee bestanden erin: a.txt en b.txt. Vervolgens voer ik dit commando uit:

git rm -r testfolder

Dit verwijderde de map samen met alle inhoud en bestanden erin

4. --dry-run

Weet je niet zeker wat er gebeurt als je een bestand verwijdert, gebruik dan git rm met de optie --dry-run zo:

git rm --dry-run <filename>

Dit is een veilige manier om te bekijken wat er verwijderd wordt. 

Of als je niet-getrackte bestanden wilt opschonen en dubbel wilt checken wat er weggaat, gebruik:

git clean -n

Dit toont alleen wat dit commando zou verwijderen.

Vergelijkende workflow-analyse

Er is meer dan één manier om een bestand in Git te verwijderen. De methoden lijken misschien hetzelfde, maar ze gedragen zich niet hetzelfde.

git rm vs handmatig verwijderen

Neem een bestand genaamd file.txt. Stel dat ik het niet meer nodig heb.

Eén manier is om het rechtstreeks van het systeem te verwijderen.

Op Linux, macOS of Git Bash:

rm file.txt

Op Windows (command prompt): 

del file.txt

Dit verwijdert het bestand uit je map. Maar Git weet dat nog niet. Dus je moet Git handmatig vertellen dat het bestand is verwijderd:

git add file.txt

Dit staged de verwijdering zodat die in de volgende commit wordt opgenomen.

Als je meerdere bestanden hebt verwijderd en niet allemaal herinnert, kun je dit draaien:

git add -u

Dit staged alle getrackte bestanden die gewijzigd of verwijderd zijn. Het omvat geen niet-getrackte bestanden.

Nu commit je de wijziging:

git commit -m "Remove file.txt"

Als je git rm gebruikt, handelt het alles in één stap af. Het verwijdert het bestand en staged de wijziging meteen:

git rm file.txtgit commit -m "Remove file.txt"

Je hoeft git add niet apart uit te voeren. Het is netter en je vergeet niet om de verwijdering te stagen.

Kort samengevat:

• Handmatig verwijderen vereist extra stappen om zeker te zijn dat Git de wijziging oppikt.
• Als je vergeet de verwijdering te stagen, denkt Git dat het bestand nog bestaat, wat verwarring kan geven bij commits of merges.
• git rm is netter en veiliger als je bewust getrackte bestanden verwijdert.

Verwijderde bestanden herstellen in Git

Wat als je een bestand verwijdert en later beseft dat je het toch nodig hebt? Geen probleem. Git geeft je een paar manieren om het terug te halen, afhankelijk van wanneer je de fout opmerkt.

Als je nog niet hebt gecommit:

Stel dat je het bestand hebt verwijderd maar de wijziging nog niet hebt gecommit. Je kunt het uit de laatste commit herstellen zoals dit: 

git restore file.txt

Dit haalt het bestand terug in je working directory vanuit de laatste commit.

Als je de verwijdering al hebt gecommit:

Ook goed. Zoek eerst de laatste commit waar het bestand nog bestond:

git log -- file.txt

Bekijk de log en kopieer de commit-hash waar het bestand nog aanwezig was. Voer dan uit:

git checkout <commit hash> -- file.txt

In oudere Git-versies kon je bovenstaand commando gebruiken. Dit herstelt een bestand uit een specifieke commit, maar kon ook van branch wisselen.

Vanaf Git 2.23 is dit opgesplitst in twee duidelijkere commando’s:

• git switch (voor van branch wisselen)
• git restore (voor bestanden herstellen)

Wil je alleen een bestand uit een commit herstellen, gebruik dan:

git restore --source=<commit-hash> --file.txt

Dit haalt het bestand uit die commit en zet het terug in je working directory.

Als je niet zeker weet wanneer het bestand is verwijderd:

Misschien heb je veel wijzigingen gedaan en weet je niet meer wanneer het bestand verdween. Gebruik in dat geval git reflog of reference log: 

git reflog

Dit toont een volledige geschiedenis van je Git-commits, checkouts, resets, alles.

Maar git reflog is alleen lokaal en werkt niet op remotes. Werk je met een remote repo, gebruik dan beter git log -- file.txt om de geschiedenis van dat bestand te volgen.

Zodra je het punt vindt waar het bestand nog bestond, herstel je het met git checkout of git restore zoals hiervoor.

Ontbrekende bestanden in Git oplossen

Soms worden bestanden rechtstreeks via het systeem verwijderd—via een bestandsverkenner, een terminal-commando rm of per ongeluk. In dat geval ruimt Git niet automatisch op. In plaats daarvan markeert Git die bestanden als ontbrekend en wacht tot jij de verwijdering goed afhandelt.

Zo pak je dat stap voor stap aan.

Stap 1: Controleer op ontbrekende bestanden

Voer dit uit in je projectmap:

git status

Als Git zegt dat een bestand is verwijderd, betekent dat dat het van je systeem weg is, maar de wijziging nog niet is gestaged.

Stap 2: Stage de verwijdering 

Om Git alle wijzigingen te laten stagen (inclusief verwijderde bestanden), voer je uit:

git add -A

• git add -A = alles stagen (nieuw, gewijzigd, verwijderd).
• git add -u = gewijzigd + verwijderd stagen, maar geen nieuwe bestanden.

Dit staget alle bestandswijzigingen: nieuw, gewijzigd en verwijderd. Commit daarna de update:

git commit -m "Removed missing files"

Dit is de veiligste manier om op te schonen, omdat het alle wijzigingen in één keer meeneemt.

Stap 3: Push naar de remote 

Als je met een remote repository werkt, push de commit dan:

git push origin <branch-name>

Vervang <branch-name> door de werkbranch, zoals main of dev.

Stap 4: Alternatief

Stel dat je een hoop bestanden handmatig hebt verwijderd, misschien per ongeluk of tijdens het opschonen. Git denkt nog steeds dat die bestanden bestaan totdat je iets anders zegt.

Als je ze niet één voor één met git rm wilt verwijderen, is er een snellere manier om op te ruimen.

Voer dit commando uit in je terminal:

git ls-files --deleted -z | xargs -0 git rm

Dit doet het volgende:

• git ls-files --deleted toont alle bestanden die Git trackt maar die nu ontbreken.
• xargs -0 git rm geeft die bestandsnamen door aan git rm en verwijdert ze uit Git’s index.

Dit is erg handig in grote projecten als je snel wilt opschonen.

Let op: Ik kreeg dit bericht omdat er geen getrackte bestanden zijn die momenteel op je schijf ontbreken.

Geavanceerd bestanden verwijderen in Git

Nu we de basis hebben behandeld, kijken we naar meer geavanceerde situaties waarin een bestand uit Git verwijderen niet zo simpel is als git rm draaien. Dit zijn gevallen waarbij gevoelige data speelt of niet-getrackte bestanden zorgvuldig moeten worden opgeschoond.

Gevoelige data uit Git verwijderen

Soms wordt een bestand met privégegevens, zoals API-sleutels of wachtwoorden, per ongeluk gecommit. Gewoon verwijderen helpt dan niet. Git bewaart een volledige geschiedenis, en het bestand bestaat nog in eerdere commits.

Om het volledig te wissen, kun je het commando git filter-repo gebruiken: git filter-repo (aanbevolen)

Dit is een nieuwer en beter alternatief voor filter-branch. Het is sneller, veiliger en makkelijker te gebruiken.

Installeer het eerst (je hebt Python en pip nodig):

pip install git-filter-repo

Voer dan uit:

git filter-repo --path hide.txt --invert-paths

Dit verwijdert het bestand hide.txt uit elke commit in de geschiedenis van je repo.

Om te bevestigen, voer uit:

git log --all -- supersecrets.txt

Als het bestand weg is, voeg het toe aan .gitignore zodat het niet opnieuw getrackt wordt:

echo hide.txt >> .gitignore

Werk je in een team, ruim de herschreven geschiedenis op en force-push de wijzigingen:

git push origin --force --all

Breng je teamgenoten daarna op de hoogte. Zij moeten hun lokale kopieën opnieuw clonen of resetten om fouten te voorkomen.

Niet-getrackte bestanden opschonen met git clean

Kort samengevat:

• Getrackte bestanden staan in Git’s geschiedenis. Gebruik git rm om ze te verwijderen en commit daarna.
• Niet-getrackte bestanden staan helemaal niet in Git. Die kunnen zich ophopen en je project vervuilen.

Gebruik git clean om niet-getrackte bestanden of mappen te verwijderen.

Dit zijn de meest nuttige opties:

git clean -n     # Show which untracked files will be removedgit clean -nd    # Show which untracked folders will be removedgit clean -fd    # Delete all untracked files and folders. It is destructive.

Hierbij geldt:

• -n betekent alleen een preview.
• -f betekent geforceerd verwijderen.
• -d neemt mappen mee in de opschoning.

Let op: git clean raakt geen getrackte bestanden. Maar het verwijdert wel alles wat niet getrackt is, ook bestanden die je misschien wilde houden. Gebruik dus altijd eerst -n om te zien wat er verwijderd wordt.

Bestanden verwijderen in GitHub & GUI-tools

Tot nu toe hebben we vooral de command line gebruikt. Maar niet iedereen werkt zo en dat is helemaal prima. Sommige ontwikkelaars gebruiken visuele tools of werken direct in GitHub.

Laten we dus bekijken hoe verwijderen werkt in de webinterface van GitHub en andere GUI-tools, en hoe dat zich verhoudt tot de command line.

Bestanden verwijderen op de GitHub-website

Werk je in de browserinterface van GitHub, dan kun je bestanden verwijderen zonder de terminal te gebruiken.

Zo werkt het in de interface van 2025:

1. Open het bestand dat je wilt verwijderen.
2. Klik op de drie puntjes rechtsboven.
3. Kies Delete file in het dropdownmenu.

GitHub toont daarna een veld voor het commitbericht. Voeg een kort bericht toe zoals:

Delete practice.py

Je kunt ook een optionele beschrijving schrijven.

Kies vervolgens hoe je de wijziging opslaat:

• Direct committen naar de main-branch
• Of een nieuwe branch aanmaken en een pull request starten (aanbevolen voor teamworkflows)

Klik op Commit changes en GitHub verwijdert het bestand en slaat de verwijdering op als een commit, net zoals git rm dat via de command line doet.

Bestanden verwijderen met Git-GUI-tools

Gebruik je een Git-GUI zoals GitHub Desktop, Sourcetree of Tower, dan is het proces ook eenvoudig:

1. Verwijder het bestand in je bestandsverkenner of binnen de app.
2. De app toont de verwijdering onder “Changes” of “File Status”.
3. Bekijk, stage en commit de wijziging.

Elke tool ziet er net anders uit, maar de workflow is vergelijkbaar: je volgt wijzigingen visueel en commit wanneer je klaar bent.

Best practices per platform

Een korte blik op hoe verwijderen werkt op verschillende platforms, en wanneer welke het handigst is:

• GitHub (Web): Goed voor snelle fixes en kleine updates. Vermijd voor grote opschoningen of gevoelige bestanden. 
• Git-GUI-tools: Fijn voor dagelijks werk. Makkelijk wijzigingen zien en veilig committen. 
• Command line: Het meest flexibel en krachtig. Beste keuze voor geavanceerde taken zoals bulkbewerkingen of geschiedenis herschrijven. 

Best practices voor bestanden verwijderen in Git

Bestanden verwijderen in Git lijkt simpel, maar één verkeerde stap kan je code breken. Dit zijn praktische tips die ik gebruik om zeker te zijn dat verwijderingen veilig en gecontroleerd gaan, vooral bij gedeelde of langlopende projecten.

Altijd verifiëren vóór je verwijdert

Neem even de tijd om te checken wat een bestand doet voordat je het verwijdert:

• Voer git status uit om te zien of het is gestaged of gewijzigd.
• Gebruik git log -- <filename> om de commithistorie te bekijken.

Deze snelle check bespaart me later uren herstelwerk.

Gebruik atomische commits

Een atomische commit betekent één commit per logische wijziging.

Als ik bijvoorbeeld ongebruikte bestanden verwijder, commit ik alleen die verwijderingen, los van code-edits.

Waarom dit helpt:

• Debuggen is makkelijker. Tools zoals git bisect werken beter wanneer commits klein en gericht zijn.
• De commithistorie blijft schoon en duidelijk.
• Code reviews gaan sneller.

Voorzichtig samenwerken bij geschiedenis herschrijven

Geschiedenis herschrijven met tools zoals git filter-repo raakt iedereen in je team. Om chaos te voorkomen:

• Communiceer voordat je gedeelde branches herschrijft.
• Gebruik git push --force voorzichtig, want het herschrijft de remote geschiedenis.
• Zeg tegen teamgenoten dat ze daarna opnieuw moeten clonen of hun lokale repo’s moeten resetten.

Gebruik --dry-run vóór destructieve commando’s

Test altijd eerst een commando dat bestanden verwijdert:

git clean -n

Dit laat zien wat er verwijderd zou worden zonder iets te verwijderen. Daarom zou je dit altijd moeten doen: 

• Het voorkomt dat je bestanden verwijdert die je eigenlijk wilt houden.
• Het is een vangnet, vooral in grote projecten waar één fout logs of gegenereerde bestanden kan wegvegen.

Combineer git rm --cached met .gitignore

Heb je per ongeluk iets gecommit dat niet in de repo hoort (zoals een configbestand of logs), los het dan in twee stappen op:

1. Stop met tracken van het bestand:```git rm --cached <filename>

git rm --cached <filename>

Dit vertelt Git te stoppen met het tracken van het bestand, maar laat het op je computer staan.

1. Voeg het toe aan .gitignore:

echo <filename> >> .gitignore

Waarom dit helpt:

• Houdt gevoelige of lokale bestanden (zoals .env, .log of node_modules) uit de repo.
• Voorkomt ruis in je Git-geschiedenis.
• Toekomstige bewerkingen aan die bestanden triggeren geen Git-wijzigingen meer.

Git-randgevallen: stagen & lege mappen

Soms loopt bestanden verwijderen anders dan verwacht. Je staged per ongeluk het verkeerde bestand of je loopt tegen problemen met lege mappen aan. 

Zo pak ik veelvoorkomende randgevallen aan.

Unstagen zonder je wijzigingen te verliezen

Stel, ik voer git add . uit en stage per ongeluk een bestand dat ik niet wilde. Ik wil mijn wijzigingen niet kwijt—ik wil het alleen uit de staging halen.

Om dat te fixen, voer ik uit:

git reset HEAD <filename>

Dit haalt het bestand uit de staging, maar laat de edits staan.

Om te bevestigen gebruik ik:

git status

Nu zou het bestand als "modified" in plaats van "staged" moeten verschijnen.

Lege mappen in de repo houden

Standaard negeert Git lege mappen. Als ik een map zonder bestanden probeer te committen, slaat Git die over.

Maar soms wil ik die map in de repo houden voor toekomstige logs of uploads. De gebruikelijke oplossing is een placeholderbestand .gitkeep toevoegen.

Zo doe je dat:

touch logs/.gitkeepgit add logs/.gitkeepgit commit -m "Keep logs folder in the repo"

Dit maakt de map “niet-leeg”, zodat Git ‘m trackt.

Let op: .gitkeep is geen ingebouwd Git-ding. Het is gewoon een conventie. Je kunt het bestand anders noemen, maar .gitkeep laat anderen zien waar het voor is.

Problemen oplossen bij bestanden verwijderen in Git

Hier zijn een paar veelvoorkomende problemen die ik tegenkom bij het verwijderen van bestanden in Git, en hoe je ze oplost.

Het bestand verschijnt nog steeds in de remote repository

Je hebt het bestand verwijderd en de wijziging gecommit, maar het staat nog op de remote. Misschien ben je vergeten te pushen.

Zorg dus dat je dit draait:

git push origin <branch-name>

Controleer ook:

• Zit je op de juiste branch?
• Zat de bestandsverwijdering daadwerkelijk in je commit?

Problemen met submodules

Submodules zijn Git-repo’s binnen andere Git-repo’s. Ze gedragen zich niet als normale mappen.

Als je bestanden binnen een submodule verwijdert:

• Ga de submodulemap in
• Commit en push de wijzigingen vanuit die submodule

Wil je de submodule helemaal verwijderen:

• Verwijder de submodulemap
• Haal verwijzingen weg uit .gitmodules en .git/config

Detached HEAD-toestand

In Git wijst HEAD meestal naar de huidige branch. Maar soms wijst het naar een specifieke commit; dat heet een detached HEAD.

Dit gebeurt als je:

• Een commit opzoekt met z’n hash
• Naar een tag wisselt
• Een remote branch uitcheckt zonder tracking in te stellen

Check je status:

git status

Als je ziet:

HEAD detached at <commit-hash>

Dan zit je niet op een branch en kunnen nieuwe wijzigingen verloren gaan als je wegschakelt.

Zo los je het op: 

Heb je wijzigingen gemaakt die je wilt behouden, voer dan dit uit:

git checkout -b <new-branch-name>

Dit zet je werk op een nieuwe branch en bewaart het.

Heb je al gecommit en wil je de wijzigingen later naar een andere branch verplaatsen, doe dan dit:

git checkout -b temp-branch          # from detached HEADgit checkout main                    # or another target branchgit merge temp-branch

Heb je geen wijzigingen gemaakt en wil je gewoon uit de detached HEAD, voer dan dit uit:

git checkout <branch-name> 

Dat is alles. Je HEAD is weer vastgemaakt en alles is terug naar normaal.

Machtigingen- of statusfouten

Soms verwijdert Git een bestand niet, meestal op Windows. Dit kan gebeuren als:

• Het bestand open staat in een ander programma
• Git geen toestemming heeft om het te updaten

Zo los je dit op:

• Sluit apps die het bestand gebruiken
• Herstart je terminal als Administrator (op Windows)

Merge- of rebase-problemen

Als je fouten ziet zoals:

• you are not currently on a branch
• merge conflict

Dan zit je waarschijnlijk midden in een merge of rebase.

Om een rebase af te ronden na het oplossen van conflicten:

git rebase --continue

Om de rebase of merge volledig te annuleren:

git reset --merge

Dit zet je repo terug zoals die was vóór de merge.

Wil je alle lokale wijzigingen weggooien en je working directory resetten? 

Probeer dit:

git restore .

Dit zet alle bestanden terug naar hun laatst gecommitteerde staat.

Tot slot 

Als je bestanden verwijdert in Git, is het makkelijk om fouten te maken als je niet oplet. Een kleine misstap kan leiden tot grotere problemen: kapotte code, werkverlies of verwarring in je team. Neem daarom even de tijd om te dubbelchecken wat je doet.

Gebruik het juiste commando voor de situatie. Als je niet zeker weet wat iets doet, test het eerst met een dry run. En werk je met anderen, zorg dan dat iedereen op één lijn zit.

Git kan veel meer dan alleen bestanden verwijderen. Je kunt branches verwijderen,  fouten herstellen met reset en revert, of precies zien wat er veranderde met git diff. Hoe meer je leert, hoe soepeler je workflow wordt.

Neem het stap voor stap. Zo word je hier goed in.