Git cherry-pick: zo selecteer en pas je specifieke commits toe

Syntax van Git cherry-pick

De syntax van git cherry-pick begrijpen is cruciaal om dit commando effectief te gebruiken. Het gaat niet alleen om commits selecteren, maar ook om ze precies toe te passen om het gewenste resultaat te bereiken.

De basis-syntax om één commit te cherry-picken is:

git cherry-pick <commit-hash>Mogelijk gemaakt door

• git cherry-pick: Het commando dat de handeling start.
• <commit-hash>: De unieke identificatie (SHA-1-hash) van de commit die je wilt cherry-picken. Je vindt deze hash door git log uit te voeren om de commitgeschiedenis te tonen.

Wanneer je bovenstaand commando uitvoert, past Git de wijzigingen van de opgegeven commit toe op de huidige branch en maakt een nieuwe commit met dezelfde wijzigingen maar een andere hash. 

Belangrijk om te weten: het commando verplaatst alleen de commit zelf, niet de context of parent-geschiedenis van de oorspronkelijke branch.

Nieuw met Git en GitHub? Begin met versiebeheer in deze beginnersvriendelijke GitHub- en Git-tutorial.

Git cherry-pick gebruiken: stapsgewijze voorbeelden

Nu je de basis-syntax van git cherry-pick begrijpt, is het tijd om het commando in actie te zien.

In deze sectie vind je praktische voorbeelden die je door veelvoorkomende basis- en meer complexe scenario’s loodsen waarin cherry-picken nuttig is. Elk voorbeeld laat zien hoe je de wijzigingen van één of meer commits toepast op een andere branch. 

Voorbeeld 1: Één enkele commit cherry-picken

Stel, je hebt een fix gemaakt op een feature-branch die je wilt toepassen op de main-branch zonder de hele feature-branch te mergen.

• Zoek eerst de hash van de commit die je wilt cherry-picken door:

git logMogelijk gemaakt door

• Zoek de commit-hash. 
• Schakel over naar de main-branch:

git checkout mainMogelijk gemaakt door

• Voer het cherry-pick-commando uit (neem aan dat de hash abc1234 is):

git cherry-pick abc1234Mogelijk gemaakt door

Wanneer je dit commando uitvoert, past Git de wijzigingen van de commit met abc1234 toe op je huidige branch (in dit geval main). Git maakt een nieuwe commit op de main-branch met dezelfde wijzigingen als de oorspronkelijke commit, maar met een nieuwe commit-hash.

Voorbeeld 2: Meerdere commits cherry-picken

In sommige situaties moet je meerdere afzonderlijke commits uit de ene branch toepassen op een andere. Stel dat je drie losse commits in je feature-branch hebt die je naar de main-branch wilt overnemen.

• Vind de commit-hashes van elke commit die je wilt cherry-picken met git log:

git logMogelijk gemaakt door

• Schakel over naar de main-branch:

git checkout mainMogelijk gemaakt door

• Voer het cherry-pick-commando uit en som de commits op:

git cherry-pick abc1234 def5678 ghi7890Mogelijk gemaakt door

Voorbeeld 3: Een bereik van commits cherry-picken

Stel dat je een reeks commits hebt gemaakt op de feature-branch en ze in één keer op de main-branch wilt toepassen zonder elke commit afzonderlijk te specificeren. Hoe pak je dat aan?

• Gebruik git log om de begin- en eindcommit te identificeren die je wilt cherry-picken (bijv. abc1234 tot ghi7890).
• Schakel over naar de main-branch:

git checkout mainMogelijk gemaakt door

• Voer het cherry-pick-commando uit met een commit-bereik:

git cherry-pick abc1234...ghi7890Mogelijk gemaakt door

Voorbeeld 4: Een commit van een remote branch cherry-picken

Soms staat een kritieke fix in een remote branch en wil je die toepassen op je lokale branch zonder de hele branch te mergen. Zo doe je dat:

• Haal de nieuwste wijzigingen op uit de remote repository

git fetch originMogelijk gemaakt door

• Toon de commits in de remote branch om de benodigde hash te vinden:

git log origin/feature_branch --onelineMogelijk gemaakt door

• Ga ervan uit dat de benodigde commit-hash abc1234 is.
• Schakel over naar je lokale main-branch:

git checkout mainMogelijk gemaakt door

• Cherry-pick de commit van de remote branch:

git cherry-pick abc1234Mogelijk gemaakt door

Zo kun je een commit uit een remote branch toepassen zonder de hele branch te mergen.

Een remote branch uitchecken? Volg deze stapsgewijze handleiding over Git checkout voor remote branches.

Voorbeeld 5: Een commit cherry-picken en aanpassen

Als je een commit cherry-pickt maar vóór het committen nog kleine aanpassingen moet doen, kun je de interactieve modus van Git gebruiken. Zo werkt het:

• Schakel over naar de doelbranch:

git checkout mainMogelijk gemaakt door

• Cherry-pick de commit maar stop vóór het committen:

git cherry-pick -n abc1234Mogelijk gemaakt door

De vlag -n (of --no-commit) past de wijzigingen toe maar maakt geen commit aan.

• Pas de bestanden aan zoals nodig.
• Stage en commit de wijzigingen handmatig:

git add .
git commit -m "Modified cherry-picked commit from feature_branch"Mogelijk gemaakt door

Dit is handig wanneer je een cherry-pickte commit wilt bijschaven vóór je hem definitief maakt.

Omgaan met conflicten tijdens Git cherry-pick

Conflicten zijn onvermijdelijk bij het cherry-picken van commits tussen branches, vooral wanneer de codebase flink is gaan divergeren. 

Hoewel cherry-pick erop is gericht wijzigingen schoon toe te passen, kan het niet altijd automatisch verschillen verzoenen. In zulke gevallen moeten conflicten handmatig worden opgelost. Begrijpen hoe conflicten ontstaan en hoe je ze afhandelt, is cruciaal om een cherry-pick-operatie te voltooien.

Hoe conflicten ontstaan

Conflicten treden meestal op wanneer de wijzigingen uit de cherry-pickte commit overlappen met of in tegenspraak zijn met wijzigingen die al in de doelbranch staan. Bijvoorbeeld:

• Dezelfde regel aangepast in beide branches: Als in zowel de bron- als de doelbranch dezelfde regel code is aangepast, weet Git niet welke versie moet worden toegepast.
• Bestand verwijderd in de ene branch maar aangepast in de andere: Als een bestand in de ene branch is verwijderd maar in de cherry-pickte commit is aangepast, weet Git niet of het behouden moet blijven of dat de wijzigingen moeten worden toegepast.
• Niet-gerelateerde wijzigingen maar in hetzelfde bestand: Zelfs als wijzigingen niet direct gerelateerd lijken, kan Git een potentieel conflict markeren als ze in hetzelfde bestand voorkomen.

Wanneer een conflict optreedt, stopt Git de cherry-pick-operatie en blijft je werkdirectory in een conflicterende staat achter die je eerst moet oplossen voordat je verder kunt.

Conflicten oplossen

Zodra er een conflict ontstaat, geeft Git aan welke bestanden conflicteren en moet je de verschillen handmatig oplossen. Zo los je conflicten op:

1. Controleer de conflicterende bestanden: Voer het volgende commando uit om te zien welke bestanden conflicteren:

git statusMogelijk gemaakt door

Het commando toont de lijst met bestanden met conflicten. 

2. Los de conflicten op: Je kunt de conflicterende bestanden handmatig bewerken om de problemen op te lossen. Verwijder de conflictmarkeringen (<<<<<<<, =======, >>>>>>>) en bepaal welke wijzigingen je behoudt of hoe je ze combineert.

3. Gebruik Git Mergetool (optioneel): Als handmatig oplossen omslachtig is, kun je een mergetool gebruiken om conflicten te visualiseren en op te lossen:

git mergetoolMogelijk gemaakt door

Afhankelijk van je configuratie opent dit een visuele mergetool, wat het eenvoudiger maakt om conflicten te beoordelen en op te lossen.

4. Markeer de conflicten als opgelost: Nadat je de conflicten hebt opgelost, markeer je de bestanden als resolved met:

git add <conflicted-file>Mogelijk gemaakt door

5. Rond de cherry-pick af: Zodra alle conflicten zijn opgelost en de bestanden staged zijn, voltooi je de cherry-pick met:

git cherry-pick --continueMogelijk gemaakt door

Veel moderne IDE’s en tools, zoals Visual Studio Code en GitHub, bieden ingebouwde functies voor het oplossen van mergeconflicten. De webinterface van GitHub laat je conflicten rechtstreeks in pull requests oplossen, waardoor samenwerken aan gedeelde repositories makkelijker wordt zonder over te schakelen naar een lokale omgeving.

Een commit overslaan na een conflict

Soms is het oplossen van een conflict te complex, of kom je erachter dat de commit toch niet nodig is. In zulke gevallen kun je de commit helemaal overslaan.

1. De huidige cherry-pick-procedure overslaan: Als het conflict te ingewikkeld is en je de commit niet wilt toepassen, kun je hem overslaan met:

git cherry-pick --skipMogelijk gemaakt door

Dit laat de conflicterende commit vallen en gaat door met de volgende (als je meerdere commits cherry-pickt).

2. De hele cherry-pick afbreken: Als je de cherry-pick-operatie helemaal wilt afbreken, voer dan uit:

git cherry-pick --abortMogelijk gemaakt door

Dit commando zet je werkdirectory terug naar de staat van vóór je met cherry-pick begon. 

Je commitgeschiedenis opschonen? Leer hoe je meerdere commits samenvoegt met deze Git squash-tutorial.

Best practices voor het gebruik van Git cherry-pick

Onjuist gebruik van cherry-pick kan leiden tot ingewikkelde geschiedenissen en verwarring in het versiebeheer van je project. Door best practices te volgen, gebruik je cherry-pick effectief zonder onnodige complexiteit in je codebase te introduceren.

Houd het klein en specifiek

Cherry-picken werkt het best voor kleine, specifieke commits die afgebakende taken behandelen, zoals bugfixes of kleine feature-verbeteringen. 

Vermijd het cherry-picken van grote, complexe commits die meerdere wijzigingen bundelen, omdat die conflicten kunnen introduceren en het beheer van de codebase lastiger maken. Hoe gerichter de commit, hoe eenvoudiger hij zonder ongewenste bijwerkingen is toe te passen.

Documenteer je cherry-picks

Zorg voor een heldere geschiedenis door altijd de juiste context te geven bij het cherry-picken. Dat kan met gedetailleerde commitberichten of aantekeningen in de documentatie. 

Kortom: leg uit waarom een cherry-pick nodig was. Dit is vooral belangrijk bij het cherry-picken tussen langlevende branches of in collaboratieve omgevingen, omdat het toekomstige bijdragers helpt te begrijpen waarom wijzigingen selectief zijn toegepast.

Bekijk de commitgeschiedenis

Bekijk vóór het cherry-picken de commitgeschiedenis van zowel de bron- als de doelbranch. Zo ontdek je of de commit die je wilt cherry-picken afhankelijk is van andere wijzigingen. Ontbrekende afhankelijkheden kunnen leiden tot onvolledige functionaliteit of bugs, dus zorg dat je met een cherry-pick geen half afgemaakte features of updates introduceert.

Vermijd overmatig cherry-picken

Hoewel cherry-picken handig is om specifieke wijzigingen toe te passen, kan overmatig gebruik leiden tot een gefragmenteerde geschiedenis met dubbele commits over branches heen. Dat maakt het lastiger om de herkomst van bepaalde wijzigingen te traceren of de bredere ontwikkelcontext te begrijpen. 

Beoordeel altijd of mergen of rebasen een passender strategie is voordat je cherry-pickt. Gebruik cherry-pick spaarzaam en doelgericht om de commitgeschiedenis overzichtelijk te houden.

Last van onnodige bestanden in Git? Leer hoe je .gitignore effectief gebruikt met deze Git ignore-tutorial.

Veelvoorkomende problemen met Git cherry-pick oplossen

Problemen oplossen die ontstaan bij het gebruik van cherry-pick vraagt om een helder begrip van de onderliggende mechanismen van Git. In deze sectie behandel ik enkele veelvoorkomende problemen die je tijdens het cherry-picken kunt tegenkomen en hoe je ze oplost.

Een commit cherry-picken die niet bestaat

Soms probeer je een commit te cherry-picken die niet toegankelijk is vanuit de huidige branch of al is gemerged. Dit resulteert meestal in een foutmelding dat de commit niet kon worden gevonden of toegepast.

1. Commit niet gevonden: Dit gebeurt wanneer de commit-hash die je wilt cherry-picken niet bestaat in je huidige repository- of branchcontext. Zorg dat je naar de juiste commit verwijst door de commitgeschiedenis te controleren met git log op de branch waar de commit staat. Oplossing:

• Controleer de commit-hash nogmaals om zeker te zijn dat deze klopt.
• Verifieer dat de commit bestaat op een branch waartoe je toegang hebt.
• Als de commit in een remote branch staat, zorg dat je de branch hebt opgehaald met git fetch.

2. Commit al toegepast: Als de commit al is gemerged of cherry-gepickt in de doelbranch, voorkomt Git dat je hem dupliceert. Deze beveiliging houdt de geschiedenis schoon en vermijdt overbodige wijzigingen. Oplossing:

• Gebruik git log om te checken of de commit al in de doelbranch zit.
• Sla de cherry-pick-operatie over als de wijzigingen al zijn toegepast.

Cherry-picken na een rebase of een merge

Cherry-picken na een rebase of merge kan complex zijn door de gewijzigde geschiedenis van je branches. Rebasen herschrijft de commitgeschiedenis, terwijl mergen branches samenvoegt; beide kunnen de toepasbaarheid van een cherry-pick beïnvloeden.

1. Conflicten door gerebasete commits: Na een rebase is de commitgeschiedenis herschreven, wat problemen kan veroorzaken als je commits wilt cherry-picken die tijdens het rebasen zijn gewijzigd. Je kunt conflicten tegenkomen omdat de cherry-pick wijzigingen probeert toe te passen die niet overeenkomen met de herschreven geschiedenis. Oplossing:

• Bekijk na een rebase zorgvuldig de commitgeschiedenis met git log om zeker te weten dat de commit die je cherry-pickt niet al is gewijzigd.
• Los conflicten op zoals bij een standaard cherry-pick-proces, met git status en handmatige bewerkingen.

2. Dubbele commits na een merge: Bij het mergen kan het gebeuren dat een commit die je wilt cherry-picken al in de samengevoegde geschiedenis zit. Nogmaals cherry-picken kan leiden tot dubbele commits, wat je geschiedenis vervuilt en het volgen van wijzigingen bemoeilijkt. Oplossing:

• Controleer vóór het cherry-picken de commitgeschiedenis op beide branches om te bevestigen of de commit al is gemerged.
• Vermijd het cherry-picken van dezelfde commit als deze al in de doelbranch staat.

Wijzigingen in Git ongedaan maken? Leer wanneer je git reset vs. git revert gebruikt in deze Git reset- en revert-tutorial.

Conclusie

git cherry-pick is een krachtige manier om specifieke commits van de ene branch naar de andere toe te passen zonder de hele branch te mergen. Of je nu een bugfix verplaatst, een feature-update of gewoon selectief wijzigingen toepast, het helpt je Git-geschiedenis schoon en gefocust te houden.

In deze gids heb ik behandeld hoe je enkele en meerdere commits cherry-pickt, conflicten oplost en best practices volgt om veelvoorkomende valkuilen te vermijden. Door cherry-pick verstandig te gebruiken, verbeter je je workflow en houd je je repository georganiseerd.

Wil je je Git-vaardigheden verdiepen? Bekijk Foundations of Git als sterk startpunt. Je kunt ook Introduction to GitHub Concepts verkennen of een gestructureerde aanpak volgen met de GitHub Foundations skill track.

Nu je weet hoe je als een pro kunt cherry-picken, ga het vooral proberen in je volgende project!