Git status: zo houd je veranderingen in je project met vertrouwen bij

Hoe gebruik je Git status

Hier is een stapsgewijze aanpak om git status effectief in je workflow te benutten.

Heb je Git nog niet geconfigureerd? Deze set-upgids loodst je door installatie en initiële configuratie op verschillende systemen.

Basisgebruik van git status

• Open je terminal:

Gebruik je favoriete terminal of command-line interface. Zo kun je direct Git-opdrachten uitvoeren en in realtime de staat van je repository bekijken.

• Navigeer naar je projectdirectory:

Gebruik het commando cd om naar de map te gaan waar je Git-project staat.

cd /path/to/your/projectMogelijk gemaakt door

• Voer git status uit:

Voer het volgende commando uit zodra je in je projectdirectory bent.

git statusMogelijk gemaakt door

Zoals we eerder zagen, geeft Git een output terug die doorgaans het volgende bevat:

• De huidige branchtitel.
• Een lijst met gestagede wijzigingen die klaar zijn om te committen.
• Een lijst met gewijzigde maar niet-gestagede bestanden.
• Eventuele ongetraceerde bestanden—nieuwe bestanden die nog niet aan Git zijn toegevoegd.

De korte weergave gebruiken

Heb je snel een snapshot nodig zonder extra details, dan is de korte weergave ideaal:

git status --shortMogelijk gemaakt door

Deze beknopte weergave toont elk bestand op één regel met status­symbolen. Handig wanneer je op een specifieke wijziging wilt scannen of dit commando in een script integreert.

Voorbeeldoutput:

 M index.html
A  new-script.js
?? temp.txtMogelijk gemaakt door

De output interpreteren:

• Het eerste teken geeft de status in de staging area aan.
• Het tweede teken geeft de status in de werkdirectory aan.

De optie -u in git status begrijpen

Met de optie -u (afkorting van --untracked-files) bepaal je hoe ongetraceerde bestanden in je output worden weergegeven, wat relevant kan zijn in projecten met veel gegenereerde bestanden. Dit betekenen de modi:

• normal (de standaard)

 Toont ongetraceerde bestanden in een standaard, ruimte-efficiënte weergave.  

Voorbeeld: 

git status -u normalMogelijk gemaakt door

Dit is het standaardgedrag dat de meeste ontwikkelaars zien bij het uitvoeren van git status.

• all

Somt elk ongetraceerd bestand op—zelfs die standaard genegeerd worden.  

Voorbeeld: 

git status -u allMogelijk gemaakt door

Deze modus geeft volledige zichtbaarheid, wat nuttig kan zijn bij het debuggen van bestandsgeneratie of het beoordelen wat via .gitignore wordt uitgesloten.

•  no

Verbergt ongetraceerde bestanden, zodat je je uitsluitend kunt richten op wijzigingen in bestanden die al door Git worden gevolgd. 

Voorbeeld:

git status -u noMogelijk gemaakt door

In een van mijn grotere projecten—een Node.js-toepassing met een complex buildproces—raakte de output van git status vervuild met tijdelijke bestanden, caches en buildartefacten. Met de optie -u no kon ik me uitsluitend richten op wijzigingen in getraceerde bestanden, zonder afleiding door tijdelijke of automatisch gegenereerde bestanden.

De output aanpassen met --porcelain

Voor scripting of automatisering is voorspelbare output essentieel. De optie --porcelain levert een schone, stabiele, machineleesbare weergave van git status, ideaal voor gebruik in maatwerktools of CI/CD-workflows:

git status --porcelainMogelijk gemaakt door

Deze modus lijkt op de korte weergave (--short), maar garandeert consistente output tussen Git-versies en -configuraties. In tegenstelling tot de standaard git status, die afhankelijk van gebruikersinstellingen extra regeleinden, hints of kleur kan bevatten, stript --porcelain al die opmaak weg—zodat scripts de output betrouwbaar kunnen parsen.

Volgende stappen na het uitvoeren van Git status

Na het uitvoeren van git status en het analyseren van de output, is het tijd om je volgende stap te bepalen—of dat nu het stagen van bestanden is, het committen van updates of het opschonen van je werkdirectory. Zo pak je dat aan.

Bestanden stagen voor een commit

Met stagen bereid je wijzigingen voor om ze in de volgende commit op te nemen. Je kunt losse bestanden stagen of alles in één keer.

• Een specifiek bestand stagen:

Gebruik dit wanneer je precies wilt bepalen wat gecommit wordt.

git add <file-name>Mogelijk gemaakt door

• Alle wijzigingen stagen:

Dit omvat gewijzigde en nieuw toegevoegde bestanden in de huidige map.

git add .Mogelijk gemaakt door

• Alle wijzigingen in getraceerde bestanden stagen (nieuwe ongetraceerde bestanden uitsluiten):

git add -uMogelijk gemaakt door

Ik raad aan om de wijzigingen met git status of git diff zorgvuldig te bekijken voordat je staged, zodat je niet per ongeluk ongewenste bestanden meeneemt. In combinatie met het git diff-commando krijg je nog diepere inzichten in wat er in je bestanden is veranderd.

Wijzigingen committen

Na het stagen van je wijzigingen is de volgende stap een commit maken. Een duidelijke en beschrijvende commitboodschap legt niet alleen vast wat er is veranderd, maar ook waarom de wijziging is doorgevoerd—wat het makkelijker maakt om de projectgeschiedenis in de tijd te begrijpen.

git commit -m "Describe your changes here"Mogelijk gemaakt door

Best practices voor commitboodschappen:

• Gebruik de gebiedende wijs (bijv. “Fix login bug”, niet “Fixed login bug”).
• Houd de samenvattingsregel indien mogelijk onder 50 tekens.
• Gebruik indien nodig een meerregelige boodschap (git commit zonder -m) om de samenvatting en een uitgebreide uitleg te scheiden.

Ik heb gemerkt dat een minuut extra om een zinvolle commitboodschap te schrijven later uren kan schelen tijdens reviews of debuggen. Zodra je wijzigingen zijn gereviewd, kun je overwegen commits te squashen om je Git-geschiedenis op te schonen.

Omgaan met ongetraceerde bestanden

Ongetraceerde bestanden kunnen je git status-output vervuilen, vooral in projecten met buildartefacten, logs of dependency-mappen. Als er bestanden of mappen zijn die je nooit wilt tracken, kun je ze uitsluiten door patronen toe te voegen aan een .gitignore-bestand in de root van je repository.

# Ignore dependency folders and log files
node_modules/
*.log

# Ignore system files
.DS_Store
Thumbs.dbMogelijk gemaakt door

Zo zorg je dat alleen relevante bestanden in je repository staan en blijft de output van git status schoon en gefocust. Wanneer je achtergebleven ongetraceerde bestanden uit je werkdirectory wilt verwijderen, is git clean ook een handig hulpmiddel.

Status regelmatig bekijken

git status vaak uitvoeren is een simpele maar krachtige gewoonte die helpt een schone en gecontroleerde ontwikkelworkflow te behouden. Je voorkomt veelgemaakte fouten zoals onvolledige wijzigingen committen of ongetraceerde bestanden over het hoofd zien door de status van je werkdirectory en staging area regelmatig te controleren—zeker vóór commits, branchwissels of merges.

Ik heb deze stap nu in mijn dagelijkse routine opgenomen, wat het aantal fouten in mijn commithistorie drastisch heeft verminderd.

Veelvoorkomende problemen met Git status oplossen

Zelfs met de eenvoud ervan kan git status soms overweldigende of verwarrende informatie geven. Hier zijn een paar veelvoorkomende problemen en hoe je ze aanpakt.

Ongewenste ongetraceerde bestanden

In grote projecten, vooral bij gebruik van diverse buildtools, kun je veel bestanden zien die je nooit wilde tracken. Als deze verschijnen, controleer dan je .gitignore-instellingen en verwijder ze indien nodig uit tracking met:

git rm --cached <file-name>Mogelijk gemaakt door

Na het bijwerken van je .gitignore en het gebruik van git rm --cached, voer je git status opnieuw uit om te verifiëren dat het bestand niet langer wordt getrackt of onnodig verschijnt.

Overweldigende output

In projecten met veel bestanden—vooral die logbestanden, caches of tijdelijke assets genereren—kan de output van git status rumoerig en lastig te scannen worden. Daardoor is het moeilijk om je te richten op de betekenisvolle wijzigingen die aandacht vragen.

In dat geval kun je een beknopte samenvatting met één regel per bestand tonen:

git status --shortMogelijk gemaakt door

Of ongetraceerde bestanden volledig uit de output verbergen:

git status -u noMogelijk gemaakt door

Samen maken deze opties git status gerichter en beter behapbaar—zeker in grotere codebases of geautomatiseerde workflows.

Conclusie

Kortom, git status is een onmisbaar hulpmiddel dat je een realtime venster geeft op de gezondheid van je repository. Door de standaardweergave, de korte weergave en geavanceerde opties zoals de -u-vlag te beheersen, kun je je Git-workflow stroomlijnen en veelvoorkomende valkuilen vermijden. Experimenteer met deze modi in je projecten en merk hoe de helderheid in het beheren van wijzigingen je ontwikkelproces versnelt.

Als je nieuw bent met Git, wordt het begrijpen van git status nog krachtiger in combinatie met git init, de opdracht die repositories initialiseert. Als je dat nog niet hebt gedaan, bekijk dan mijn Git Init-tutorial om te leren hoe je een repository vanaf nul opzet.

En als je je Git-vaardigheden verder wilt verdiepen, bekijk dan deze DataCamp-cursussen:

• Intermediate Git – Versterk je skills met technieken voor branching, mergen en het oplossen van conflicten.
• GitHub Foundations – Leer Git met GitHub te integreren voor samenwerkingsprojecten.

Happy coding—en op naar perfecte synchronisatie met je repository!