Hoe gebruik je .gitignore: een praktische introductie met voorbeelden

Leer hoe je .gitignore gebruikt om je Git-repository schoon te houden. Deze tutorial behandelt de basis, veelvoorkomende use-cases en praktische voorbeelden om je op weg te helpen!

Bijgewerkt 1 jun 2026 · 8 min lezen

Als je met Git werkt, is je repository schoon en georganiseerd houden niet alleen een best practice—het is essentieel voor soepele samenwerking en efficiënte versiecontrole. Daar komt .gitignore om de hoek kijken. Dit handige bestand vertelt Git welke bestanden het moet negeren, zodat onnodige rommel wordt voorkomen en je commits gericht blijven op wat echt belangrijk is.

Zonder .gitignore kan je repo al snel vollopen met tijdelijke bestanden, logs en andere dingen die niet thuishoren in versiebeheer. Nog erger: je kunt per ongeluk gevoelige informatie delen.

In deze tutorial leer je hoe je een .gitignore-bestand maakt en gebruikt om je project netjes te houden, veelgemaakte valkuilen te vermijden en effectiever met Git te werken. Laten we beginnen!

Wat is een .gitignore-bestand?

Een .gitignore-bestand is een configuratiebestand in Git dat het versiebeheersysteem instrueert welke bestanden of mappen genegeerd moeten worden wanneer wijzigingen worden gestaged of gecommit.

Het voorkomt dat onnodige bestanden—zoals tijdelijke, systeemaangemaakte of build-gerelateerde bestanden—je repository vervuilen. Een schone repository maakt samenwerken makkelijker en zorgt ervoor dat alleen essentiële bestanden worden gevolgd.

Het .gitignore-bestand is een eenvoudig tekstbestand dat in de hoofdmap van je Git-repository staat. Het bevat patronen die Git vertellen welke bestanden of mappen genegeerd moeten worden. Deze patronen kun je aanpassen aan de behoeften van je project, zodat je een goed georganiseerde repository behoudt.

Nieuw met Git en GitHub? Krijg een beginnersvriendelijke introductie tot versiebeheer met deze GitHub- en Git-tutorial.

Hier zijn enkele veelvoorkomende categorieën bestanden en mappen die je zou moeten overwegen te negeren:

Build-artifacts: Bestanden die tijdens het buildproces worden gegenereerd en opnieuw gemaakt kunnen worden vanuit de broncode, zoals:

dist/, build/ (Frontend- en backend-builduitvoer)
target/ (Java en andere gecompileerde taalbuilds)

Dependencies: Pakketbeheersystemen maken mappen aan voor geïnstalleerde libraries, die niet gevolgd hoeven te worden:

node_modules/ (Node.js)
vendor/ (PHP, Composer)
.venv/, venv/ (Python-virtuele omgevingen)

Systeemspecifieke bestanden: Deze bestanden worden automatisch door het besturingssysteem gegenereerd en dragen niet bij aan het project:

.DS_Store (macOS)
Thumbs.db (Windows)

IDE-configuratiebestanden: Elke ontwikkelaar kan een andere ontwikkelomgeving gebruiken, dus hun persoonlijke instellingen horen niet in versiebeheer:

.vscode/ (VS Code)
.idea/ (JetBrains IDE's)
.project, .settings/ (Eclipse)

Logs en tijdelijke bestanden: Logs, caches en tijdelijke bestanden moeten genegeerd worden om onnodige rommel te voorkomen:

*.log, npm-debug.log*, yarn-debug.log*, yarn-error.log* (Logs van diverse tools)
*.tmp, *.bak (Tijdelijke en back-upbestanden)
.mypy_cache/, __pycache__/ (Python-caches)
.ipynb_checkpoints/ (Jupyter Notebook-checkpoints)

Omgevings- en geheime bestanden: Gevoelige inloggegevens en omgevingsspecifieke configuraties mogen nooit gecommit worden:

.env, .env.local, .env.development, .env.production
secrets.json, config.json (Gevoelige configuratiebestanden)

Database- en opslagbestanden: Deze worden lokaal gegenereerd en horen niet in versiebeheer:

*.sqlite, *.sqlite3, *.db (SQLite-databasebestanden)
dump.rdb (Redis-databasedump)

CI/CD- en coverage-bestanden: Testrapporten en andere CI/CD-artifacts moeten genegeerd worden:

coverage/, *.lcov (Code coverage-rapporten)
.tox/, .pytest_cache/ (Python-testbestanden)

Git installeren? Volg onze stapsgewijze handleiding in deze Git-installatietutorial om snel aan de slag te gaan.

Syntaxis van .gitignore

Zoals genoemd bevatten .gitignore-bestanden patronen die worden vergeleken met bestandsnamen in je repository om te bepalen of ze genegeerd moeten worden.

Basissynthese

In de kern bestaat het .gitignore-bestand uit regels, elk een patroon dat genegeerd moet worden. Patronen kunnen overeenkomen met:

Specifieke bestanden
Bestandstypen
Mappen

Het bestand ondersteunt ook opmerkingen, die je kunt toevoegen door een regel te beginnen met #, en lege regels voor de leesbaarheid.

Hier is een overzicht van de basisstructuur:

Een specifiek bestand negeren: Je kunt de bestandsnaam direct opnemen om het te negeren.

secrets.txt

Een hele map negeren: Door een / toe te voegen aan het einde van de mapnaam, negeer je alles in die map.

logs/

Alle bestanden van een bepaald type negeren: Jokers (*) kunnen worden gebruikt om alle bestanden met een specifieke extensie te negeren.

*.py

Negatie: Je kunt ! gebruiken om een patroon te negëren en expliciet bepaalde bestanden of mappen te volgen die anders genegeerd zouden worden.

*.txt  # Ignores all .txt files
!readme.txt  # Except for readme.txt

Hoe maak en gebruik je een .gitignore-bestand

Een .gitignore maken en gebruiken is vrij eenvoudig. In dit onderdeel neem ik je mee door de stappen.

Een .gitignore-bestand maken

Stap 1: Ga naar de hoofdmap van je repository. Het .gitignore-bestand staat meestal in de hoofdmap van een Git-project. Open je terminal of opdrachtregel en navigeer naar de hoofdmap van je Git-repository:

cd /path/to/your/repo

Stap 2: Maak het .gitignore-bestand. Eenmaal in de hoofdmap maak je het .gitignore-bestand met een teksteditor of door een opdracht in de terminal uit te voeren, zoals:

touch .gitignore

Stap 3: Voeg patronen toe aan het bestand. Open het .gitignore-bestand in een teksteditor en voeg de nodige patronen toe om bestanden of mappen te negeren. Elke regel stelt een ander patroon voor.

Hier is een voorbeeld van een .gitignore-bestand dat vaak in een basisproject wordt gebruikt:

# Ignore node_modules and dependency directories
node_modules/
vendor/

# Ignore build artifacts
dist/
build/
*.log

# Ignore system-generated files
.DS_Store
Thumbs.db

# Ignore environment and secret files
.env
config.json

Zodra je de benodigde patronen hebt toegevoegd, sla je het bestand op. Git negeert deze bestanden nu automatisch bij het stagen of committen van wijzigingen.

Stap 4: Commit het bestand naar de repository. Het is belangrijk om het .gitignore-bestand te committen naar de repository zodat alle samenwerkers dezelfde ignore-regels gebruiken. Dit zorgt voor consistentie in het project voor iedereen die betrokken is.

git add .gitignore
git commit -m "Add .gitignore file"
git push

Zodra het .gitignore-bestand is gecommit, stel je gedeelde ignore-regels in voor het hele team.

Wil je pushen en pullen in Git onder de knie krijgen? Leer hoe je je werk synchroniseert met remotoe repositories in deze tutorial over Git push en pull.

Best practices voor het gebruik van .gitignore

Hoewel het maken van een .gitignore-bestand een eenvoudig onderdeel is van het onderhouden van een schone Git-repository, zijn er verschillende best practices om te zorgen dat het bestand op de lange termijn effectief beheerd wordt.

Gebruik een globale .gitignore

Voor ontwikkelaars die aan meerdere projecten werken, zijn er specifieke bestanden die je in elke repository wilt uitsluiten, ongeacht het type project.

In plaats van ze aan het .gitignore-bestand van elk project toe te voegen, kun je een globale .gitignore configureren die op alle repositories op je systeem van toepassing is.

Zo configureer je een globale .gitignore:

Maak een .gitignore_global-bestand:

touch ~/.gitignore_global

Voeg patronen toe voor bestanden die je overal wilt negeren, zoals:

.DS_Store
*.log
/.vscode/
/.idea/

Stel Git in om de globale .gitignore te gebruiken:

git config --global core.excludesfile ~/.gitignore_global

Maak gebruik van bestaande templates

In plaats van voor elk nieuw project een .gitignore-bestand vanaf nul op te bouwen, kun je vooraf geconfigureerde .gitignore-templates gebruiken voor specifieke talen, frameworks of omgevingen.

Een van de beste bronnen voor deze templates is GitHub’s officiële .gitignore-repository, waar je .gitignore-bestanden vindt die zijn afgestemd op honderden programmeertalen en frameworks.

Controleer .gitignore regelmatig

Naarmate projecten evolueren, kunnen nieuwe bestanden en mappen aan het .gitignore-bestand moeten worden toegevoegd. Het is belangrijk om je bestand periodiek te controleren en bij te werken zodat het de huidige stand van je projecten weerspiegelt.

Enkele scenario’s waarin je het .gitignore-bestand mogelijk moet bijwerken:

Nieuwe tools of libraries gebruiken die extra bestanden genereren (bijv. overstappen op een nieuw build-systeem).
Refactoren of herstructureren van mappen, wat kan leiden tot nieuwe bestanden die uitgesloten moeten worden.
Verouderde bestanden of mappen verwijderen die geen deel meer uitmaken van het project.

Problemen oplossen met .gitignore

Zelfs na het instellen van een .gitignore-bestand kun je situaties tegenkomen waarin specifieke bestanden toch worden gevolgd, of patronen niet lijken te werken zoals verwacht. In dit onderdeel behandelen we twee veelvoorkomende probleemgebieden en hoe je ze oplost.

Bestanden volgen die al gecommit zijn

Het .gitignore-bestand werkt niet met terugwerkende kracht op al gecommitteerde bestanden.

Als je een patroon aan .gitignore toevoegt nadat bepaalde bestanden al gecommit zijn, blijft Git ze volgen, ook al komen ze overeen met het patroon in het .gitignore-bestand.

Om te stoppen met het volgen van bestanden die al gecommit zijn, volg je deze stappen:

Verwijder de bestanden uit Git’s tracking: Gebruik het commando git rm om ze uit de repository te verwijderen terwijl je ze in je werkmap behoudt.

git rm --cached <file_or_directory_name>

Commit de wijzigingen: Nadat je de bestanden uit Git’s tracking hebt verwijderd, commit je de wijzigingen zodat de bestanden geen deel meer uitmaken van de versiegeschiedenis.

git commit -m "Stop tracking ignored files"

Push de wijzigingen naar de remote repository: Push tot slot de wijzigingen naar de remote repository zodat de bestanden niet langer gevolgd worden.

git push

Na deze stappen stopt Git met het volgen van de bestanden. Het gecommitteerde bestand staat nog steeds in je werkmap, maar wordt in toekomstige commits genegeerd op basis van je .gitignore-patronen.

Controleren of patronen werken

Soms merk je dat specifieke bestanden waarvan je verwachtte dat ze genegeerd werden, toch in de status van Git verschijnen of worden gevolgd.

Volg deze stappen om te controleren of je .gitignore-patronen correct werken:

Controleer de status van je bestanden: Gebruik het commando git status om te zien welke bestanden door Git worden gevolgd. Dit helpt je te verifiëren of je genegeerde bestanden nog steeds worden vermeld.

git status

Zorg dat het patroon klopt: Controleer de syntaxis van je .gitignore-patronen om zeker te zijn dat ze goed geformatteerd zijn. Bijvoorbeeld:

Zorg dat je het juiste mappad gebruikt (relatief aan de root van de repository).
Voeg een / toe om specifieke mappen te targeten en te voorkomen dat alle bestanden met vergelijkbare namen gevolgd worden.

Ververs de cache: Als je je .gitignore-bestand recent hebt bijgewerkt en de wijzigingen niet worden toegepast, houdt Git mogelijk de vorige cache vast. Om de cache te verversen, voer je het volgende commando uit:

git rm -r --cached .
git add .
git commit -m "Refresh .gitignore"

Controleer op uitzonderingen: Soms kan een specifiek patroon in .gitignore overschreven worden door een specifieker patroon elders in het bestand. Bekijk je regels om te zorgen dat er geen conflicterende patronen zijn.

Op zoek naar een snelle Git-referentie? Houd essentiële commando’s binnen handbereik met deze Git-cheat sheet.

Conclusie

Een .gitignore-bestand lijkt misschien klein, maar het speelt een grote rol in het schoon en beheersbaar houden van je Git-repository. Door onnodige bestanden—zoals dependencies, build-artifacts en systeemaangemaakte bestanden—te negeren, blijft je project georganiseerd en vrij van rommel.

In deze tutorial heb je geleerd hoe je een .gitignore-bestand maakt, patronen toevoegt en best practices toepast om je repo efficiënt te houden. Met deze vaardigheden voorkom je hoofdpijn bij versiebeheer en maak je samenwerking voor iedereen in je team soepeler.

Wil je je Git-vaardigheden verder uitbouwen? Bekijk Git Fundamentals voor een gestructureerd leerpad. Je kunt ook praktijkgerichte cursussen volgen zoals Foundations of Git en Introduction to GitHub Concepts om een solide begrip te krijgen van versiebeheer en samenwerkingsworkflows!