Git stash uitgelegd: wijzigingen opslaan, herstellen en beheren

Wat is Git stash?

git stash is een Git-commando dat je niet-gecommitete wijzigingen tijdelijk opzij zet zodat je terug kunt naar een schone werkmap, zonder een Git-commit te maken. Zo kun je eenvoudig van branch wisselen of dringend werk oppakken zonder voortgang te verliezen.

Stashes worden opgeslagen in een LIFO-stack (last-in, first-out). De meest recente stash is altijd stash@{0}, gevolgd door stash@{1}, enzovoort.

Standaard slaat git stash gewijzigde tracked files en gestaged changes (van de index) op. Nieuwe ongetrackte bestanden en genegeerde bestanden, zoals die in .gitignore, worden echter niet meegenomen.

Wijzigingen opslaan met git stash

In dit onderdeel laat ik je drie gangbare manieren zien om wijzigingen te stashen. We gebruiken steeds hetzelfde scenario: stel dat je werkt aan een datapijplijnproject met de bestanden data_pipeline.py, config.yaml en tests/test_pipeline.py.

Tracked changes stashen

Omdat git stash gewijzigde of gestagede wijzigingen opslaat, kun je git status uitvoeren om de status van de bestanden in je werkmap te controleren. Na het draaien van git stash worden zowel gestagede als niet-gestagede tracked wijzigingen opgeslagen, en houd je een schone werkmap over.

Ongetrackte wijzigingen en nieuwe bestanden meenemen

Standaard negeert git stash bestanden die nog nooit aan de repository zijn toegevoegd. Als je een nieuw testbestand hebt gemaakt, laat een standaard stash het in je map staan, wat problemen kan geven bij het wisselen van branches.

Als je git stash draait, blijft dat bestand aanwezig. Gebruik -u of --include-untracked om het mee te nemen:

git stash -u

Om echt elk bestand mee te nemen, inclusief bestanden die expliciet genegeerd worden door je .gitignore, kun je git stash --all of -a gebruiken. Wees hier echter voorzichtig mee, want zo kun je per ongeluk logs of build-artifacts meenemen.

Geef je stash een naam

Bij gebruik van git stash worden standaardberichten zoals WIP on main onduidelijk als je meerdere stashes hebt. Voeg daarom altijd een beschrijvend bericht toe wanneer je de stashes wilt pushen. 

git stash push -m "refactor pipeline config handling."

Met het commando git stash list kun je de stashlijst bekijken en vergelijken. Let op het verschil tussen de benoemde stash en de standaard stashes.

Duidelijke berichten maken het veel makkelijker om later de juiste stash te vinden, zeker wanneer je meerdere taken tegelijk doet of samenwerkt met een team.

Ik raad je aan om onze GitHub Foundations- en Git Fundamentals-skill tracks te proberen om versiebeheer met Git te leren van basis tot gevorderde workflows, inclusief wijzigingen bijhouden, repositories beheren en efficiënt samenwerken. 

Je stashes bekijken en inspecteren

Voordat je blind een stash toepast, is het belangrijk om te controleren wat erin zit. Deze stap wordt vaak overgeslagen, maar helpt verwarring of per ongeluk overschrijven te voorkomen.

git stash list: alle stashes weergeven

Gebruik het onderstaande commando om je stashstack te zien:

git stash list

Je weet nu dat stashes een LIFO-volgorde (last-in, first-out) volgen. De meest recente stash is altijd stash@{0}, en elke nieuwe stash duwt oudere verder omlaag in de stack.

git stash show: een stash inspecteren vóór toepassen

Voor een snelle samenvatting van de wijzigingen in een stash kun je het commando show op een specifieke stash gebruiken. Het onderstaande commando toont bijvoorbeeld de wijzigingen in de laatste stash:

git stash show stash@{0}

Om de daadwerkelijke codewijzigingen (de volledige diff) te zien, gebruik je onderstaand commando om alle regel-voor-regelwijzigingen in die stash te tonen.

git stash show -p stash@{0}

Controleer als best practice altijd een stash vóór je deze toepast, zeker als hij een paar dagen oud is of als je niet precies weet wat erin zit.

Stashed wijzigingen herstellen

Zodra je je werk met git stash hebt opgeslagen, heb je een manier nodig om het terug te halen. Er zijn twee hoofdmethoden om stashes te herstellen, inclusief hoe je een specifieke stash op index richt.

git stash pop: toepassen en verwijderen

Dit is de meest gebruikelijke manier om een stash te herstellen. Het pakt de bovenste stash (stash@{0}), past de wijzigingen toe op je huidige branch en verwijdert die stash vervolgens uit de stack.

git stash pop

Na pop zijn je wijzigingen hersteld en is de stash verwijderd. Gebruik pop dus wanneer je zeker weet dat je met die opgeslagen staat klaar bent en je de stashlijst netjes wilt houden.

Voor een diepere uitleg van het pop-commando raad ik onze Git Stash Pop-tutorial aan om te leren hoe je niet-gecommit werk bewaart wanneer je in je repo van branch wisselt.

git stash apply: toepassen en bewaren

Wil je wijzigingen herstellen maar de stash bewaren voor hergebruik, gebruik dan apply als volgt:

git stash apply stash@{1}

Door een stash via de index te refereren, zoals stash@{1}, richt je je op die specifieke stash voor herstel. Dit is handig als je dezelfde wijzigingen op meerdere branches wilt toepassen, zoals een gedeelde config-aanpassing die zowel naar main als staging moet.

Met git stash list kun je controleren of de stash er na apply nog staat.

Selectief stashen

In echte projecten lopen je wijzigingen vaak door elkaar. In zulke gevallen wil je misschien slechts een deel van je werk stashen en de rest beschikbaar houden. Git biedt twee methoden voor fijnmazige controle.

git stash push -m: specifieke bestanden stashen

Als je precies weet welke bestanden je even wilt parkeren, kun je alleen geselecteerde bestanden stashen door hun paden op te geven:

Het onderstaande commando stasht bijvoorbeeld alleen het bestand data_pipeline.py. Dit is handig als je werk aan een experimentele feature wilt pauzeren terwijl je een bugfix gestaged en klaar om te committen wilt houden.

git stash push -m "stash experimental pipeline logic" data_pipeline.py

Gebruik git status om te controleren of je commando is geslaagd en bekijk de situatie vóór en ná in je repo.

git stash push -p -m: specifieke hunks interactief stashen

Soms staan de “goede” code en de “WIP”-code in hetzelfde bestand. Gebruik in dat geval de vlag -p of --patch om een interactieve sessie te starten. Hiermee kun je specifieke stukken (“hunks”) wijzigingen binnen een bestand kiezen.

git stash push -p -m "Selective stash of pipeline logic"

Je ziet dan “Stash this hunk” met deze opties:

• y: Ja, deze hunk stashen

• n: Nee, deze hunk overslaan

• q: Stoppen; deze en overige hunks niet stashen.

• a: Alles; deze hunk en alle volgende hunks in het bestand stashen.

• d: Delete; deze en alle volgende hunks in het bestand niet stashen.

• ?: help

Let op dat deze workflow sterk lijkt op git add -p. Dit is handig wanneer wijzigingen binnen hetzelfde bestand niet gerelateerd zijn en apart moeten worden afgehandeld.

Je stash opruimen

Stashes zijn bedoeld als kortdurend. Als je ze laat opstapelen, wordt het later lastiger om de juiste te vinden en neemt het risico op conflicten toe wanneer je ze uiteindelijk toepast.

git stash drop: een specifieke stash verwijderen

Om één stash te verwijderen, gebruik je git stash drop met de index. Het onderstaande commando verwijdert bijvoorbeeld de 4e stash in de lijst.

git stash drop stash@{3}

Zoals je hierboven ziet, wordt de stashlijst verkleind en worden de overgebleven stashes na het verwijderen opnieuw geïndexeerd.

git stash clear: alle stashes wissen

Om alle stashes in één keer te verwijderen, gebruik je:

git stash clear

Dit commando geeft bij succes geen output. Je kunt het controleren met git stash list.

Wees extra voorzichtig met git stash clear, want deze actie is permanent en er is geen ingebouwde undo. Draai dit alleen als je zeker weet dat je geen enkele stash meer nodig hebt.

git stash branch: een stash omzetten naar een branch

Als je huidige branch aanzienlijk is afgeweken sinds je de stash maakte, kan toepassen leiden tot mergeconflicten. In dat geval kun je rechtstreeks vanuit de stash een nieuwe branch aanmaken:

git stash branch pipeline-fix stash@{1}

Bovenstaand commando doet het volgende:

• Maakt een nieuwe branch vanaf de oorspronkelijke commit waarop de stash is gemaakt
• Past de stash toe
• Verwijdert hem uit de stashlijst

Bekijk ook onze Git Branch-tutorial om meer te leren over het beheren van branches voor betere ontwikkeling en samenwerking.

Andere Git stash-commando’s die de moeite waard zijn

Naast de gebruikelijke workflows zijn dit enkele geavanceerde git stash-commando’s om te kennen:

• git stash create: maakt een stash-object zonder het aan de stashlijst toe te voegen

• git stash store: slaat een met create gemaakte stash op

• git stash export: exporteert een stash naar een referentie of print deze

• git stash import: importeert een stash uit een bestaande commit

Veelvoorkomende fouten en hoe je ze oplost

Hoewel git stash eenvoudig is, kunnen een paar veelvoorkomende issues je toch verrassen. Hier zijn enkele fouten die ik ben tegengekomen en hoe je ze snel herkent en oplost.

No local changes to save

Dit is de meest voorkomende “niet-fout”-fout. Het gebeurt wanneer je git stash draait in een schone werkmap waar geen gewijzigde of gestagede tracked files zijn.

Voer git status uit om dit te checken; als er niets verschijnt, is er niets te stashen.

Conflict bij het toepassen van een stash

Conflicten ontstaan wanneer de branch waarop je zit dezelfde regels code heeft gewijzigd als in je stash. Als je bijvoorbeeld git stash pop draait op de nieuwe branch nadat je het bestand hebt aangepast, krijg je waarschijnlijk een foutmelding:

Je ziet dan mogelijk conflictmarkeringen in het bestand:

Om dit op te lossen kun je het volgende doen:

• Conflicten handmatig in het bestand oplossen
• De opgeloste bestanden stagen

git add data_pipeline.py

• De stash handmatig droppen met git stash drop (als hij NIET automatisch is verwijderd bij het conflict)

Als conflicten te rommelig zijn, gebruik dan onderstaand commando om de wijzigingen in een schone tak toe te passen.

git stash branch recovery-branch stash@{0}

Per ongeluk bestanden gestasht die je niet bedoelde

Soms draai je git stash zonder je werkmap te checken, om later te merken dat je een fix hebt weggestopt die je eigenlijk wilde committen.

Voorkom dit door altijd expliciet te zijn over de bestanden die je wilt stashen. Het onderstaande commando stasht bijvoorbeeld alleen het bestand data_pipeline.py in plaats van alles in de werkmap.

git stash push data_pipeline.py

Je kunt ook git stash -p gebruiken voor interactieve (patch)modus, zodat je selectief delen van wijzigingen binnen bestanden kunt stashen, niet hele bestanden.

Controleer ter preventie altijd git status vóór je stasht.

Conclusie

Houd stashes bij voorkeur kortdurend en gebruik altijd beschrijvende berichten. Als je niet binnen een dag terugkeert naar het werk, is een WIP-branch aanmaken veiliger, omdat je die naar een remote kunt pushen en hij niet kwijtraakt.

Om je Git-skills te versterken raad ik onze Intermediate Git-cursus aan om te leren samenwerken in Git. Ik raad ook onze Advanced Git-cursus aan om te leren werken met Git voor grote projecten en complexe versiebeheerscenario’s en -issues in datapijplijnontwikkeling.