Git-branch wisselen: een gids met praktische voorbeelden

De namen van bestaande branches opvragen

Als we de beschikbare branches willen tonen, gebruiken we het commando git branch. De huidige branch wordt met een asterisk ervoor weergegeven. Als we bijvoorbeeld drie lokale branches hebben met de namen main, feature-x en bug-z, en we staan nu op de branch main, dan is de output:

* main
feature-x
bug-z

Wisselen naar een remote branch

Met het vorige commando kunnen we wisselen naar een branch die we al lokaal hebben. Om naar een branch uit de remote repository te wisselen, moeten we er lokaal een versie van aanmaken met het volgende commando:

git switch -c <local-branch-name> origin/<remote-branch-name>

Hier is <local-branch-name> de naam die we de branch lokaal willen geven, en <remote-branch-name> is de naam van de remote branch. Meestal gebruiken we dezelfde naam om verwarring te voorkomen. Stel dat we de branch feature-x niet lokaal hebben. Dan kunnen we een lokale versie aanmaken en erheen wisselen zoals hieronder:

git switch -c feature-x origin/feature-x

Als je dezelfde naam gebruikt, biedt Git een verkorte notatie met de optie --track. Het bovenstaande commando is dan gelijk aan:

git switch --track origin/feature-x

Om de remote branches te tonen, kunnen we het commando git branch -r gebruiken.

De lokale repository houdt niet automatisch de remote branches bij. Daarom is het belangrijk om vóór het tonen of wisselen naar een remote branch de lokale repository te updaten met git fetch.

Een nieuwe branch aanmaken en ernaartoe wisselen

We willen een gloednieuwe branch aanmaken om aan een nieuwe feature te beginnen. In dat geval kunnen we de vlag -c gebruiken:

git switch -c <new-branch-name>

We vervangen <new-branch-name door de naam van de branch. Om bijvoorbeeld een branch feature-y te maken, doen we het volgende:

git switch -c feature-y

Terugschakelen naar de vorige branch

Vaak wil je na het wisselen om wat werk te doen, weer terug naar de branch waar je eerder mee bezig was. Git biedt hiervoor een korte notatie met het commando:

git switch -

Git Switch vs. Git Checkout

Het commando git checkout bestaat al sinds het begin van Git. Voor de introductie van git switch in 2019 gebruikten we git checkout om tussen branches te wisselen. Maar de reikwijdte van git checkout gaat verder dan alleen navigeren tussen branches. Hier zijn de verschillen op een rij:

• git switch: Heeft als doel een meer intuïtieve manier te bieden om te wisselen en nieuwe branches aan te maken. Het vereenvoudigt de set aan commando’s en vermindert verwarring.
• git checkout: Een veelzijdiger commando dat je kunt gebruiken om van branch te wisselen, maar ook om bestanden te checkouten en content uit verschillende commits of branches te herstellen.

Het ontwerp van git switch maakt het lastiger om per ongeluk wijzigingen te overschrijven. Het heeft een explicietere syntax voor het wisselen en aanmaken van nieuwe branches.

Omdat git checkout meerdere dingen doet (branches wisselen, bestanden herstellen, enz.), is de kans groter dat je fouten maakt bij het gebruik ervan.

Git Switch: veelvoorkomende fouten

Bij het beheren van branches kun je tegen een paar veelvoorkomende problemen aanlopen. Eén daarvan is proberen een branch aan te maken die lokaal al bestaat. Een andere is proberen te wisselen met niet-gecomitte wijzigingen. Laten we met de eerste beginnen.

De branch bestaat lokaal al

Elke lokale branch heeft een unieke naam nodig. Je kunt met git switch op twee manieren lokale branches aanmaken:

1. Om een remote branch te tracken:

git switch --track origin/<branch-name>

2. Om een nieuwe lokale branch aan te maken:

git switch -c <branch-name>

In beide gevallen zal Git een fout geven als er al een lokale branch met de naam <branch-name> bestaat:

fatal: a branch named '<branch-name>' already exists

In dit geval kunnen we gewoon naar de branch wisselen zonder die aan te maken met git switch <branch-name>.

De huidige branch heeft niet-gecomitte wijzigingen

Git laat ons niet van branch wisselen als de huidige branch niet-gecomitte wijzigingen heeft die door het wisselen zouden worden overschreven. In dat geval geeft Git de volgende foutmelding:

Please commit your changes or stash them before you switch branches.

Zoals het bericht aangeeft, moeten we in deze situatie eerst onze wijzigingen committen of stashen. Als de wijzigingen klaar zijn om te committen, doen we dat met:

git commit -m "Commit message"

Als we de wijzigingen willen bewaren maar nog niet willen committen, kunnen we ze tijdelijk opslaan met het git stash-commando:

git stash

Als we vóór het wisselen de wijzigingen stashen en we willen ze opnieuw toepassen wanneer we teruggaan naar de oorspronkelijke branch, gebruiken we git stash pop.

Als alternatief kunnen we er ook voor kiezen de wijzigingen te verwerpen met de vlag --discard-changes:

git switch --discard-changes <branch-name>

Wees voorzichtig met deze laatste optie, want de wijzigingen worden permanent verwijderd.

Geavanceerd gebruik van Git Switch

Als je branches moet maken vanaf specifieke punten in de geschiedenis van je project of speciale scenario’s wilt afhandelen, biedt git switch geavanceerde functionaliteit om aan die behoeften te voldoen.

Branching vanaf een specifiek punt

Standaard, wanneer je een branch aanmaakt met git switch, is de beginsituatie van de nieuwe branch de HEAD van de branch waar we ons momenteel op bevinden.

Stel dat we een nieuwe branch vanaf een specifieke eerdere commit willen starten. Iedere commit heeft een unieke <hash> die we met het commando git switch kunnen gebruiken om vanaf die commit een nieuwe branch te maken. Zo doe je dat:

switch -c feature-y <hash>

Vervang <hash> door de daadwerkelijke commit-hash.

Wisselen naar een detached head

Als we een bepaalde commit willen verkennen of experimenteren zonder de huidige branch te beïnvloeden of een nieuwe branch te maken, kunnen we een detached head gebruiken met het commando:

git switch --detach <hash>

Door de head te detachen kunnen we veilig de staat van de repository op een specifieke commit inspecteren, tests draaien of tijdelijke wijzigingen maken zonder het risico dat die per ongeluk naar de huidige werk-branch worden gecommit. Veelvoorkomende use-cases zijn:

• Een oude staat bekijken: als we een oudere commit willen inspecteren of testen zonder de huidige branch te wijzigen, kunnen we naar die commit schakelen in een detached state.
• Tijdelijke wijzigingen: als we willen experimenteren met wijzigingen zonder een branch te beïnvloeden, kunnen we dat doen in een detached head. Let op: nieuwe commits in deze staat horen niet bij een branch; maak een nieuwe branch als je die commits wilt behouden.
• Build-/testdoeleinden: soms moeten we software bouwen of testen op een specifieke commit. Wisselen naar een detached HEAD op die commit maakt dat mogelijk zonder impact op de branch-structuur van de repository.

Wisselen forceren

We hebben gezien dat Git ons niet laat wisselen als er niet-gecomitte wijzigingen zijn die kunnen conflicteren met de doelbranch. Als we zeker weten dat we die wijzigingen willen verwerpen en toch willen wisselen, kunnen we dit forceren met de optie -f:

git switch -f <branch-name>

Er zijn belangrijke kanttekeningen om rekening mee te houden. 

• Alle niet-gecomitte wijzigingen gaan zonder waarschuwing verloren, wat kan leiden tot verlies van werk als die wijzigingen niet elders zijn opgeslagen. 
• Ongecontroleerd gebruik van -f kan tot gemakzucht leiden, waardoor developers goede versiebeheerpraktijken zoals stashen of WIP (work-in-progress) committen omzeilen. Dit kan resulteren in een chaotische repositorygeschiedenis en samenwerking bemoeilijken. Daarom biedt git switch -f weliswaar snelheid en gemak, maar gebruik het spaarzaam en met begrip van de risico’s om nadelen te beperken.

Conclusie

Het commando git switch maakt wisselen en branches aanmaken eenvoudiger dan het oudere git checkout.

Het vereenvoudigt het proces en helpt fouten te verminderen, waardoor developers hun codebase makkelijker kunnen beheren.

Dit commando helpt veelvoorkomende problemen te voorkomen, zoals per ongeluk wijzigingen overschrijven of de verschillende functies van git checkout door elkaar halen.

Door dit commando te gebruiken wordt navigeren tussen Git-branches intuïtiever en verbetert de samenwerking binnen developmentteams.