.gitignore

git add git commit git diff git stash .gitignore

Git ziet elk bestand in je werkkopie als een van de volgende drie dingen:

bijgehouden - een bestand dat eerder is opgevoerd of gecommit;
niet-bijgehouden - een bestand dat niet is opgevoerd of gecommit;
genegeerd - een bestand waarvan Git expliciet is verteld dat het moet worden genegeerd.

Genegeerde bestanden zijn meestal build-artefacten en door de machine gegenereerde bestanden die kunnen worden afgeleid van de bron van je repository of die anderszins niet moeten worden gecommit. Enkele veelvoorkomende voorbeelden zijn:

afhankelijkheidscaches, zoals de inhoud van /node_modules of /packages;
gecompileerde code, zoals .o-, .pyc- en .class-bestanden;
build-uitvoermappen, zoals /bin, /out of /target;
bestanden die tijdens runtime zijn gegenereerd, zoals.log, .lock, of .tmp;
verborgen systeembestanden, zoals .DS_Store of Thumbs.db;
persoonlijke IDE-configuratiebestanden, zoals .idea/workspace.xml.

Genegeerde bestanden worden bijgehouden in een speciaal bestand met de naam .gitignore dat is ingecheckt in de hoofdmap van je repository. Er is geen expliciete 'git ignore'-opdracht: in plaats daarvan moet het .gitignore-bestand met de hand worden bewerkt en gecommit wanneer je nieuwe bestanden hebt die je wilt negeren. .gitignore-bestanden bevatten patronen die overeenkomen met bestandsnamen in je repository om te bepalen of ze al dan niet moeten worden genegeerd.

Bestanden negeren in Git

Git ignore-patronen

.gitignore gebruikt globbing-patronen om overeenkomsten te zoeken met bestandsnamen. Je kunt je patronen construeren met verschillende symbolen:

Patroon	Voorbeeldovereenkomsten	Uitleg*
`**/logs`	`logs/debug.log` `logs/monday/foo.bar` `build/logs/debug.log`	Je kunt een patroon vooraf laten gaan door een dubbele asterisk zodat overeenkomsten worden gezocht met mappen in de gehele repository.
`**/logs/debug.log`	`logs/debug.log` `build/logs/debug.log` maar niet `logs/build/debug.log`	Je kunt ook een dubbele asterisk gebruiken om bestanden te matchen op basis van hun naam en de naam van hun bovenliggende map.
`*.log`	`debug.log` `foo.log` `.log` `logs/debug.log`	Een asterisk is een jokerteken dat overeenkomt met nul of meer tekens.
`*.log` `!important.log`	`debug.log` `trace.log` maar niet `important.log` `logs/important.log`	Door vooraan een uitroepteken te plaatsen, zal het patroon het negeren. Als een bestand overeenkomt met een patroon, maar ook met een ontkenningspatroon dat later in het bestand is gedefinieerd, wordt het niet genegeerd.
`.log` `!important/.log` `trace.*`	`debug.log` `important/trace.log` maar niet `important/debug.log`	Patronen die ná een ontkenningspatroon zijn gedefinieerd, zullen alle eerder ontkende bestanden opnieuw negeren.
`/debug.log`	`debug.log` maar niet `logs/debug.log`	Door vooraan een slash toe te voegen, worden alleen bestanden in de hoofdmap van de repository gezocht.
`debug.log`	`debug.log` `logs/debug.log`	Patronen komen standaard overeen met bestanden in een map
`debug?.log`	`debug0.log` `debugg.log` maar niet `debug10.log`	Een vraagteken komt overeen met precies één karakter.
`debug[0-9].log`	`debug0.log` `debug1.log` maar niet `debug10.log`	Er kunnen ook blokhaken worden gebruikt om een enkel teken uit een bepaalde reeks te matchen.
`debug[01].log`	`debug0.log` `debug1.log` maar niet `debug2.log` `debug01.log`	Blokhaken komen overeen met één teken uit de opgegeven set.
`debug[!01].log`	`debug2.log` maar niet `debug0.log` `debug1.log` `debug01.log`	Een uitroepteken kan worden gebruikt voor overeenkomsten met elk teken, behalve één uit de opgegeven set.
`debug[a-z].log`	`debuga.log` `debugb.log` maar niet `debug1.log`	Reeksen kunnen numeriek of alfabetisch zijn.
`Logboeken`	`logs` `logs/debug.log` `logs/latest/foo.bar` `build/logs` `build/logs/debug.log`	Als je geen slash voor de naam plaatst, zoekt het patroon zowel bestanden als de inhoud van mappen met die naam. In het voorbeeld links worden zowel mappen als bestanden met de naam logs genegeerd.
logs/	`logs/debug.log` `logs/latest/foo.bar` `build/logs/foo.bar` `build/logs/latest/debug.log`	Het toevoegen van een slash vooraan geeft aan dat het patroon een map is. De volledige inhoud van elke map in de repository die overeenkomt met die naam — inclusief alle bestanden en submappen — wordt genegeerd.
`logs/` `!logs/important.log`	`logs/debug.log` `logs/important.log`	Wacht even! Zou `logs/important.log` niet moeten worden genegeerd in het voorbeeld links? Nee hoor! Vanwege een prestatiegerelateerde eigenaardigheid in Git kun je een bestand dat wordt genegeerd niet negeren vanwege een patroon dat overeenkomt met een map
`logs/**/debug.log`	`logs/debug.log` `logs/monday/debug.log` `logs/monday/pm/debug.log`	Een dubbele asterisk komt overeen met nul of meer mappen.
`logs/*day/debug.log`	`logs/monday/debug.log` `logs/tuesday/debug.log` maar niet `logs/latest/debug.log`	Jokertekens kunnen ook worden gebruikt in mapnamen.
`logs/debug.log`	`logs/debug.log` maar niet `debug.log` `build/logs/debug.log`	Patronen die een bestand in een bepaalde map opgeven, zijn relatief ten opzichte van de hoofdmap van de repository. (Je kunt desgewenst een slash vooraan plaatsen, maar die doet niets bijzonders.)

** deze uitleg gaat ervan uit dat je .gitignore-bestand zich bevindt in de map op het hoogste niveau van je repository, net als de conventie. Als je repository meerdere .gitignore-bestanden heeft, kun je gewoon in je hoofd de 'hoofdmap van de repository' vervangen door 'map met het .gitignore-bestand' (en overwegen om ze samen te voegen ten behoeve van je team).*

Naast deze tekens kun je # gebruiken om opmerkingen op te nemen in je .gitignore-bestand:

# ignore all logs
*.log

Je kunt \ gebruiken om .gitignore-patroontekens uit te sluiten als je bestanden of mappen hebt die deze bevatten:

# ignore the file literally named foo[01].txt
foo\[01\].txt

Gedeelde .gitignore-bestanden in je repository

Git ignore-regels worden meestal gedefinieerd in een .gitignore-bestand in de hoofdmap van je repository. Je kunt er echter voor kiezen om meerdere .gitignore-bestanden te definiëren in verschillende mappen in je repository. Elk patroon in een bepaald .gitignore-bestand wordt getest ten opzichte van de map met dat bestand. De conventie, en de eenvoudigste aanpak, is echter om één .gitignore-bestand te definiëren in de hoofmap. Als je .gitignore-bestand is ingecheckt, vindt er versiebeheer plaats zoals voor elk ander bestand in je repository en wordt het bestand gedeeld met je teamgenoten wanneer je het pusht. Meestal moet je alleen patronen opnemen in .gitignore die andere gebruikers van de repository ten goede zullen komen.

Persoonlijke Git ignore-regels

Je kunt ook persoonlijke negeerpatronen opgeven voor een bepaalde repository in een speciaal bestand op .git/info/exclude. Daarbij is er geen sprake van versiebeheer. Ook worden deze bestanden niet gedistribueerd met je repository. Dit is dus een geschikte plaats om patronen op te nemen die je waarschijnlijk alleen maar ten goede zullen komen. Als je bijvoorbeeld een aangepaste configuratie voor logs hebt of speciale ontwikkelingshulpmiddelen gebruikt die bestanden produceren in de werkmap van je repository, kun je overwegen deze toe te voegen aan .git/info/exclude om te voorkomen dat ze per ongeluk worden vastgelegd in je repository.

Algemene Git ignore-regels

Daarnaast kun je algemene Git ignore-patronen definiëren voor alle repositories op je lokale systeem door de Git-eigenschap core.excludesFile in te stellen. Je moet dit bestand zelf aanmaken. Als je niet zeker weet waar je je globale .gitignore-bestand moet plaatsen, dan is je hoofdmap geen slechte keuze (en bovendien kun je het bestand daardoor later gemakkelijk terugvinden). Nadat je het bestand hebt aangemaakt, moet je de locatie configureren met git config:

$ touch ~/.gitignore
$ git config --global core.excludesFile ~/.gitignore

Wees voorzichtig met de patronen die je in het algemeen wilt negeren, aangezien verschillende bestandstypen relevant zijn voor verschillende projecten. Speciale bestanden van het besturingssysteem (bijv. .DS_Store en thumbs.db) of tijdelijke bestanden die door sommige ontwikkelaartools zijn aangemaakt, zijn typische bestanden die je in het algemeen kunt negeren.

Een eerder gecommit bestand negeren

Als je een bestand wilt negeren dat je in het verleden hebt gecommit, moet je het bestand uit je repository verwijderen en vervolgens een .gitignore-regel voor dat bestand toevoegen. Het gebruik van de --cached optie met git rm zorgt ervoor dat het bestand uit je repository wordt verwijderd, maar in je werkmap blijft staan als een genegeerd bestand.

$ echo debug.log >> .gitignore
  
$ git rm --cached debug.log
rm 'debug.log'
  
$ git commit -m "Start ignoring debug.log"

Je kunt de optie --cached weglaten als je het bestand uit zowel de repository als het lokale bestandssysteem wilt verwijderen.

Een genegeerd bestand committen

Het is mogelijk om een genegeerd bestand te forceren dat moet worden toegevoegd aan de repository. Gebruik daarvoor de optie -f (of --force) met git add:

$ cat .gitignore
*.log
  
$ git add -f debug.log
  
$ git commit -m "Force adding debug.log"

Je zou kunnen overwegen dit te doen als je een algemeen patroon hebt gedefinieerd (zoals *.log), maar een specifiek bestand wilt committen. Een betere oplossing is echter om een uitzondering op de algemene regel te definiëren:

$ echo !debug.log >> .gitignore
  
$ cat .gitignore
*.log
!debug.log
  
$ git add debug.log
  
$ git commit -m "Adding debug.log"

Deze aanpak is duidelijker en minder verwarrend voor je teamgenoten.

Een genegeerd bestand stashen

git stash is een krachtige Git-functie voor het tijdelijk 'opbergen' en terugdraaien van lokale wijzigingen, zodat je ze later opnieuw kunt toepassen. Zoals je zou verwachten, negeert git stash standaard genegeerde bestanden en worden alleen wijzigingen opgeslagen in bestanden die door Git worden gevolgd. Je kunt echter git stash aanroepen met de optie --all, zodat wijzigingen in genegeerde en niet-bijgehouden bestanden ook worden opgeslagen.

Fouten opsporen in .gitignore-bestanden

Als je ingewikkelde .gitignore-patronen hebt of patronen die zijn verspreid over meerdere .gitignore-bestanden, kan het moeilijk zijn om te achterhalen waarom een bepaald bestand wordt genegeerd. Je kunt de opdracht git check-ignore gebruiken met de optie -v (of --verbose) om te bepalen welk patroon ervoor zorgt dat een bepaald bestand wordt genegeerd:

$ git check-ignore -v debug.log
.gitignore:3:*.log  debug.log

De uitvoer ziet er als volgt uit:

<file containing the pattern> : <line number of the pattern> : <pattern>    <file name>

Je kunt meerdere bestandsnamen doorgeven aan git check-ignore als je wilt. De namen zelf hoeven niet eens overeen te komen met bestanden die in je repository bestaan.