Git-branches weergeven: een praktische gids

Als je ooit aan meer dan één feature tegelijk hebt gewerkt, klinkt dit vast bekend: je voert een Git-opdracht uit en nu weet je niet meer zeker waar je werk van vorige week eigenlijk staat.

Dit probleem komt vaker voor naarmate projecten groeien. In het begin heeft een repository misschien alleen een main-branch. Na verloop van tijd maken teams echter branches voor nieuwe features, bugfixes, experimenten, releases en dringende hotfixes. 

Hier komt het overzicht van branches in Git van pas. Het helpt bij praktische vragen:

• Op welke branch werk ik nu?
• Welke andere branches staan op mijn machine?
• Welke branches bestaan er op de remote repository?

In deze gids bekijken we de basis van het weergeven van branches in Git, hoe je dat doet en hoe je veelvoorkomende problemen oplost.

Is Git helemaal nieuw voor je? Volg dan eerst onze cursus Introduction to Git om zelfvertrouwen op te bouwen voordat je in meer gedetailleerde branchbeheer-onderwerpen duikt.

Git-branches begrijpen

Voordat we ze gaan weergeven, leggen we kort uit wat Git-branches zijn. 

Een veelvoorkomend misverstand is dat Git-branches losse mappen of volledige kopieën van een codebase zijn, maar in werkelijkheid is een Git-branch slechts een lichtgewicht verwijzing naar een specifieke commit.

Je kunt het zien als een parallelle tijdlijn waarin je features kunt bouwen of experimenteren in isolatie, zonder je stabiele hoofdcode te beïnvloeden. Deze architectuur maakt het aanmaken en mergen van branches razendsnel en efficiënt.

Bron: Git

Git houdt je huidige positie in deze tijdlijnen bij met een speciale referentie genaamd HEAD, die altijd wijst naar de branch waar je nu aan werkt. Omdat branches slechts verwijzingen zijn, is van context wisselen onmiddellijk en hoeven er geen grote bestanden verplaatst te worden.

Meer weten? Bekijk onze tutorial over Git-branches of raadpleeg onze Git-cheat sheet.

Lokale branches weergeven in Git

Met die conceptuele basis op zak bekijken we hoe je lokale branches in je repository weergeeft.

Een lokale branch is een branch die op jouw computer bestaat. Deze staat in de .git-map van je repository en vertegenwoordigt een verplaatsbare verwijzing naar een reeks commits. Je kunt naar een lokale branch overschakelen, wijzigingen maken en er nieuwe commits op aanmaken.

Het helpt om lokale branches zo te zien:

• Ze behoren tot jouw kopie van de repository
• Ze schuiven door wanneer je nieuwe wijzigingen commit
• Ze updaten niet automatisch wanneer anderen code pushen

Met git branch

De meest gebruikte en fundamentele opdracht om lokale branches weer te geven is heel eenvoudig:

git branchMogelijk gemaakt door

Als je deze opdracht zonder extra opties uitvoert, laat Git je alle lokale branches zien.

Belangrijke dingen om te onthouden over git branch:

• Toont alleen lokale branches, geen remote
• Maakt geen internetverbinding
• Verandert geen bestanden, commits of branchgeschiedenis

Omdat het veilig en snel is, voeren veel developers git branch uit als gewoonte voordat ze nieuw werk starten of van context wisselen.

De output begrijpen

Hier is een voorbeeld van wat git branch kan tonen:

 bugfix/login-timeout
  feature/payment-refactor
* mainMogelijk gemaakt door

Hoewel deze output simpel lijkt, zitten er een paar belangrijke details in verstopt.

Ten eerste geeft het sterretje (*) de branch aan die momenteel is uitgecheckt. Dit is de branch waarop je werkdirectory nu is afgestemd. Nieuwe commits komen op deze branch terecht.

Ten tweede markeert Git de huidige branch meestal in het groen. Dit is alleen visuele hulp van de terminal en verandert het gedrag van Git niet.

Ten derde: let op wat er niet wordt getoond:

• Geen commitdatums
• Geen auteursnamen
• Geen remote-informatie

Dit is bewust zo. Git houdt de standaardoutput kort, zodat je die gemakkelijk kunt scannen en combineren met andere opdrachten.

Tip voor beginners: Als je terminal ooit lijkt te "hangen" na een Git-opdracht, probeer dan q te drukken. Git gebruikt vaak een pager om lange output te tonen; dit is de normale manier om die af te sluiten.

Alleen de huidige branch opvragen

Soms is het overbodig om alle branches te tonen. Je wilt misschien alleen weten op welke branch je nu zit. Git heeft daar een aparte opdracht voor:

git branch --show-currentMogelijk gemaakt door

De output is alleen de branchnaam:

mainMogelijk gemaakt door

Veelvoorkomende situaties waarin dit handig is:

• Je branch checken voordat je code pusht
• De branchnaam loggen in scripts
• De branchnaam gebruiken in automatisering of CI-pijplijnen

Als Git in een detached HEAD-state is, geeft deze opdracht niets terug. Dat lijkt misschien vreemd, maar het is juist handig bij het schrijven van scripts die moeten detecteren of er een branch is uitgecheckt.

Veelgemaakte fout: Sommige gebruikers denken dat Git "kapot" is als er geen branchnaam verschijnt. In de meeste gevallen betekent dit simpelweg dat je niet op een branch zit, maar op een specifieke commit.

Remote en alle branches weergeven in Git

Remote of zelfs alle branches in Git weergeven werkt vrijwel hetzelfde als lokale branches tonen.

Remote branches in Git weergeven

Remote repositories, zoals die op GitHub of GitLab, hebben hun eigen branches. Om die te bekijken, voeg je de -r-vlag toe:

git branch -rMogelijk gemaakt door

  origin/HEAD -> origin/main
  origin/bugfix/login-timeout
  origin/feature/payment-refactor
  origin/mainMogelijk gemaakt door

Deze voorbeeldoutput kan in het begin verwarrend zijn, dus laten we het even ontleden.

Wat je hier ziet zijn remote-tracking branches. Dit zijn lokale verwijzingen die Git gebruikt om de laatst bekende status van de remote repository te onthouden.

Belangrijke punten om te begrijpen:

• Deze branches worden lokaal opgeslagen
• Ze worden alleen geüpdatet wanneer je fetcht
• Ze bewegen niet automatisch mee

Tip voor beginners: Zie remote-tracking branches als het notitieboekje van Git. Git schrijft op hoe de remote er de laatste keer uitzag, maar werkt dat notitieboekje niet bij tenzij je expliciet fetcht.

Alle branches in Git weergeven

Om lokale branches en remote-tracking branches samen te zien, gebruik je de -a-vlag:

git branch -aMogelijk gemaakt door

* main
  feature/payment-refactor
  remotes/origin/bugfix/login-timeout
  remotes/origin/mainMogelijk gemaakt door

Dit gecombineerde overzicht helpt je begrijpen hoe je lokale branches zich verhouden tot de remote.

Naamgevingspatronen om op te letten:

• Lokale branches verschijnen als simpele namen zoals main

• Remote-tracking branches verschijnen onder remotes/origin/

Dit overzicht is vooral handig wanneer je wilt beslissen of je een nieuwe lokale branch maakt die een bestaande remote branch volgt. Als je een repository moet clonen en aan een specifieke branch wilt werken, bekijk dan onze gids over hoe je een specifieke branch in Git clonet.

Altijd eerst fetchen

Als een teamgenoot een nieuwe branch pusht en jij die niet ziet, is de meest voorkomende reden dat je lokale cache verouderd is. 

De oplossing is fetchen:

git fetchMogelijk gemaakt door

Wat git fetch doet:

• Downloadt de nieuwste branch-informatie van de remote
• Werkt je remote-tracking branches bij
• Laat je werkbestanden ongewijzigd

Deze opdracht is altijd veilig om uit te voeren. Het merged geen code en overschrijft je werk niet. Veel teams zien git fetch als een routine-stap voordat ze branches inspecteren.

Veelgemaakte fout: Beginners verwarren git fetch vaak met git pull. Fetch werkt alleen branch-informatie bij, terwijl pull ook wijzigingen merge’t in je huidige branch.

Meer details opvragen over je Git-branchlijst

Soms zijn branchnamen niet genoeg. Als je extra details wilt zien, zijn er een paar handige vlaggen die je helpen.

Laatste commits bekijken

Om te zien wat elke branch daadwerkelijk bevat, gebruik je:

git branch -vMogelijk gemaakt door

De output kan er zo uitzien:

* main   a1b2c3d Fix typo in README
  feature/payment-refactor e4f5g6h Refactor payment serviceMogelijk gemaakt door

Zoals je ziet, voegt de -v-vlag belangrijke context toe:

• De korte commit-hash toont waar de branch nu naar wijst
• Het commitbericht geeft een hint over het doel van de branch

Dit is een van de eenvoudigste manieren om te begrijpen waar een branch voor dient zonder deze uit te checken.

Tip voor beginners: Weet je niet zeker of een branch veilig te verwijderen is? Het laatste commitbericht checken is een goede eerste aanwijzing. Voor een complete gids over het verwijderen van branches, zie onze tutorial over hoe je Git-branches verwijdert.

Upstream-koppelingen controleren

Lokale branches volgen vaak een bijbehorende remote branch. Om deze relatie te zien, voer je uit:

git branch -vvMogelijk gemaakt door

* main   a1b2c3d [origin/main] Fix typo in README
  feature/payment-refactor e4f5g6h [origin/feature/payment-refactor] Refactor payment serviceMogelijk gemaakt door

Deze output vertelt je:

• Met welke remote branch je lokale branch is gekoppeld

• Vanwaar git pull zal binnenhalen

• Waarnaartoe git push zal verzenden

Als een branch geen upstream heeft, verschijnt er niets tussen blokhaken. Dit verklaart vaak push- of pullfouten.

Veelgemaakte fout: git pull uitvoeren op een branch zonder upstream mislukt meestal. Stel in dat geval eerst een upstream-branch in of push de branch voor de eerste keer.

Branches sorteren op datum of versie

Om recent actieve branches te vinden, kun je sorteren op commitdatum:

git branch --sort=-committerdateMogelijk gemaakt door

Dit plaatst de meest recent geüpdatete branches bovenaan en oudere onderaan.

Voor repositories met versienummer-branches is semantisch sorteren handiger:

git branch --sort=v:refnameMogelijk gemaakt door

Dit respecteert versienummers en voorkomt verwarrende alfabetische volgorde.

De branchlijst filteren in Git

Als je naar een specifieke branch zoekt, kan filteren erg handig zijn. Ik laat je zien hoe je dat doet met een paar belangrijke vlaggen.

Zoeken op naamspatroon

Zeker in grote repositories kan filteren op naam je veel tijd besparen bij het vinden van de juiste branch. Je kunt op naam filteren met de --list-vlag samen met je zoekterm:

git branch --list 'feature/*'Mogelijk gemaakt door

Let op hoe de * als wildcard wordt gebruikt: het resultaat toont alleen branches die overeenkomen met het patroon, dus die beginnen met feature. Teams gebruiken vaak prefixen zoals feature/, bugfix/ of hotfix/ om alles georganiseerd te houden. Zie ze als mappen voor je branches.

Samengevoegde vs. niet-samengevoegde branches vinden

Twee heel belangrijke filters zijn:

git branch --merged
git branch --no-mergedMogelijk gemaakt door

Deze opdrachten vergelijken andere branches met je huidige branch.

• --merged toont branches waarvan het werk al is opgenomen (lees meer over Git merge)

• --no-merged toont branches die nog unieke commits bevatten

Veiligheidsherinnering: Controleer altijd dubbel of je op de juiste basisbranch staat (vaak main of develop) voordat je --merged gebruikt. De resultaten hangen af van je huidige branch.

Zoeken welke branch een commit bevat

Als je een commit-hash weet en wilt vinden waar die bestaat, gebruik dan deze opdracht:

git branch --contains <commit-hash>Mogelijk gemaakt door

Dit is handig bij het opsporen van bugs of controleren of een fix is gemerged.

Bijvoorbeeld, als een collega je dit vertelt: "Ik heb een bug gevonden in deze commit-hash; welke branches worden erdoor geraakt?" Met deze opdracht kun je de exacte locatie van de bug achterhalen.

Filters combineren voor geavanceerde workflows

De filters die ik liet zien, kun je combineren om de resultaten verder te verfijnen. Eén voorbeeld:

git branch --list 'feature/*' --no-mergedMogelijk gemaakt door

Het resultaat van deze opdracht toont snel alle niet-gemergede feature/-branches en helpt het team georganiseerd te blijven.

Veelvoorkomende problemen oplossen

Als je tegen problemen aanloopt, geen zorgen; de meest voorkomende issues zijn vrij eenvoudig te verhelpen.

Ontbrekende remote branches

Als je een branch die iemand anders heeft gepusht niet kunt zien, is de meest waarschijnlijke reden dat je simpelweg bent vergeten te fetchen. Zo los je het op:

1. Voer git fetch uit

2. Toon daarna de branches opnieuw

Als het missen van een fetch het probleem was, werkt deze snelle fix je lokale weergave direct bij.

De detached HEAD-state

Soms ziet de output van git branch er zo uit:

* (HEAD detached at a1b2c3d)Mogelijk gemaakt door

Dit betekent dat je niet op een branch zit. Je bekijkt direct een specifieke commit.

In een detached HEAD-state zijn is op zichzelf niet gevaarlijk, maar nieuwe commits die je maakt kunnen later lastig terug te vinden zijn, tenzij je een branch aanmaakt.

Om weer normaal te werken, schakel je over naar een bestaande branch:

git checkout <branch-name>Mogelijk gemaakt door

Moderne alternatief: Sinds Git 2.23+ kun je git switch <branch-name> gebruiken, een schonere en veiligere opdracht speciaal voor het wisselen van branches.

Je kunt ook vanaf je huidige positie een nieuwe branch maken met de -b-vlag:

git checkout -b <new-branch-name>Mogelijk gemaakt door

Branches blijven zichtbaar na verwijderen

Als remote branches blijven verschijnen na verwijderen op de server, kun je hun lokale verwijzing opschonen met de volgende opdracht:

git remote prune originMogelijk gemaakt door

Dit ruimt verouderde verwijzingen op en houdt je repository netjes.

Pro tip: Als alternatief kun je ook git fetch --prune gebruiken telkens wanneer je fetcht, zodat de repo in één stap wordt bijgewerkt én opgeschoond.

Conclusie

Branches weergeven in Git is een kernvaardigheid die je helpt je repository te begrijpen. De opdrachten en vlaggen in deze tutorial helpen je fouten te vermijden en vol vertrouwen samen te werken met anderen. 

Als je een nieuw project start, is het vaak de moeite waard om na te denken over het soort branch-structuur dat je nodig hebt. Voor advies, bekijk deze gids over een Git-branchingstrategie.

Klaar om verder te gaan dan de basis? De Git Fundamentals-skill track biedt de concepten en hands-on ervaring die je nodig hebt om van beginner naar pro te gaan.