/

Zo gebruikt u git stash: een stapsgewijze gids

door Team Ninja
How to Use Git Stash blog banner
How to Use Git Stash blog banner

Try our #1 rated endpoint management platform on G2

NinjaOne dashboard screenshot

Automate the Hardest Parts of IT

Belangrijkste punten

  • Gebruik git stash om uw huidige wijzigingen op te slaan. Dit commando bewaart uw niet-gecommitte werk en zet uw working directory terug naar de laatste commit.
  • Gebruik git stash push -m “bericht” om een stash een label of notitie te geven.
  • Gebruik git stash list om alles te zien wat u hebt gestasht. U ziet dan van elke stash de identifier en het bijbehorende bericht.
  • Gebruik git stash apply om gestashte wijzigingen terug te halen en de stash als achtervang te bewaren of git stash pop om de stash te verwijderen zodra die opnieuw is toegepast.
  • Gebruik git stash drop voor één stash of git stash clear om ze allemaal te verwijderen wanneer u stashes niet langer nodig hebt.
  • Voeg de vlag –include-untracked of de korte vorm -u toe om nieuwe, untracked bestanden in een stash op te nemen.

Git stash is een Git-commando waarmee u niet-gecommitte wijzigingen in uw working directory tijdelijk opslaat. Zo wisselt u van branch of taak zonder onafgemaakt werk te committen.

In deze gids duiken we in git stash: we beginnen met het basisidee, het nut en de use cases. Daarna behandelen we de basis, zoals het terughalen en beheren van stashes en bekijken we geavanceerde technieken. We sluiten af met beste praktijken en het belang van git stash in softwareontwikkeling, zodat u een compleet beeld krijgt.

Git en het belang van git stash

Voordat we ingaan op de details van git stash, is het belangrijk om Git zelf te begrijpen. Git is kort gezegd een gedistribueerd versiebeheersysteem dat breed wordt gebruikt in softwareontwikkeling om wijzigingen in broncode bij te houden. Door het gedistribueerde karakter kunnen meerdere ontwikkelaars tegelijk aan dezelfde codebase werken zonder elkaar in de weg te zitten.

Deze functies maken Git onmisbaar voor ontwikkelaars:

  • Branchen en mergen: met het branchmodel van Git werken ontwikkelaars in geïsoleerde omgevingen, “branches” genoemd en voegen ze hun wijzigingen naadloos weer samen met de broncode.
  • Snelheid en efficiëntie: Git is gebouwd op prestaties. De bewerkingen zijn snel, waardoor Git geschikt is voor projecten van elke omvang.
  • Data-integriteit: Git waarborgt de integriteit van broncode door een volledige historie en volledig versiebeheer bij te houden.

Met dit beeld van Git op zak kunnen we dieper ingaan op het commando git stash. Dit gereedschap komt minder vaak ter sprake dan bijvoorbeeld git commit of git merge, maar kan een onmisbaar onderdeel van de gereedschapskist van een ontwikkelaar zijn.

Wat is git stash?

Het commando git stash is een krachtige functie in Git. Het is in feite een manier om de huidige staat van uw working directory en index op te slaan zonder te committen. Zie het als een klembord voor niet-gecommitte wijzigingen: een snapshot die u later opnieuw kunt toepassen. Deze functie is een wezenlijk onderdeel van versiebeheer, omdat u wijzigingen in code er flexibeler en efficiënter mee beheert. Het zet wijzigingen in uw working directory tijdelijk opzij – het “stasht” ze – zodat u aan iets anders kunt werken en er later op terug kunt komen.

Git stash is vooral nuttig in deze situaties:

1. Werk in uitvoering opslaan

Scenario: een ontwikkelaar moet overschakelen naar een andere branch om een kritiek probleem op te lossen, maar zit midden in het doorvoeren van een nieuwe bugfix.

Use case: git stash slaat de huidige wijzigingen op zonder ze te committen. Zo kunnen ontwikkelaars naar een andere branch overschakelen of wijzigingen doorvoeren voordat ze terugkeren naar de oorspronkelijke branch en hun gestashte wijzigingen ophalen.

2. De working directory opschonen

Scenario: een ontwikkelaar heeft niet-gecommitte wijzigingen in de working directory die niet verloren mogen gaan, maar wil vanaf nul aan een nieuwe functie beginnen.

Use case: git stash haalt niet-gecommitte wijzigingen tijdelijk weg. Het schoont de working directory op, zodat ontwikkelaars vanaf nul aan een nieuwe functie kunnen beginnen en hun eerdere wijzigingen daarna weer kunnen toepassen.

3. Verschillende aanpakken testen

Scenario: een ontwikkelaar werkt aan een oplossing en wil een nieuwe aanpak uitproberen zonder het huidige werk kwijt te raken.

Use case: met git stash kunnen ontwikkelaars hun huidige wijzigingen stashen om verschillende aanpakken te proberen. Dat geeft hun een schone lei om mee te experimenteren. Werkt de nieuwe aanpak niet, dan keren ze terug naar hun gestashte wijzigingen.

4. Mergeconflicten oplossen

Scenario: een ontwikkelaar wil een aantal wijzigingen tijdelijk stashen om andere dringende kwesties op te pakken terwijl hij werkt aan een oplossing voor een complex mergeconflict.

Use case: git stash slaat wijzigingen tijdelijk op, zodat ontwikkelaars zich op andere kwesties kunnen richten en daarna terugkeren naar het oplossen van mergeconflicten.

5. Gedeeltelijk stashen

Scenario: een ontwikkelaar wil uit alle wijzigingen in de working directory slechts een deel stashen.

Use case: met git stash stasht u specifieke bestanden of delen daaruit, waardoor ontwikkelaars meer grip hebben op wat er gestasht wordt.

6. Aan meerdere functies tegelijk werken

Scenario: een ontwikkelaar moet wisselen tussen meerdere functies waaraan tegelijkertijd wordt gewerkt.

Use case: met git stash slaan ontwikkelaars hun voortgang op de functie waaraan ze werken op, zodat ze naar een andere functie kunnen overschakelen zonder hun wijzigingen kwijt te raken. Ze stashen hun werk op een feature branch, schakelen over naar een andere branch en passen de gestashte wijzigingen opnieuw toe zodra ze terugkeren naar de functie waaraan ze werkten.

7. Codereviews

Scenario: een ontwikkelaar moet niet-gecommitte wijzigingen in de working directory laten staan om de code van een collega te beoordelen.

Use case: met git stash stashen ontwikkelaars hun wijzigingen, beoordelen ze de code van hun collega en passen ze hun gestashte wijzigingen opnieuw toe zodra ze terugkeren naar hun working directory.

8. Een back-up maken van niet-gecommit werk

Scenario: een ontwikkelaar wil een back-up maken van niet-gecommitte wijzigingen naar een andere branch of een remote repository.

Use case: met git stash stasht u wijzigingen, maakt u een nieuwe branch vanuit de stash, pusht u die branch naar een remote repository en maakt u zo een back-up van het niet-gecommitte werk van een ontwikkelaar.

9. Samenwerken

Scenario: een ontwikkelaar werkt in een gedeelde repository en moet de laatste versie ophalen zonder lokale wijzigingen kwijt te raken.

Use case: met git stash stashen ontwikkelaars hun wijzigingen en halen ze vervolgens de laatste wijzigingen of updates uit de remote repository op. Daarna passen ze hun gestashte wijzigingen opnieuw toe.

10. Workflows automatiseren

Scenario: een ontwikkelaar gebruikt scripts of hooks die een schone working directory vereisen.

Use case: met git stash stashen ontwikkelaars hun wijzigingen voordat ze scripts of hooks uitvoeren. Daarna passen ze die wijzigingen opnieuw toe, zodat automatiseringsprocessen altijd met een schone working directory werken.

Dit zijn slechts de meest voorkomende use cases van git stash. Ze laten zien hoe flexibel het commando is in het bieden van oplossingen en het stroomlijnen van ontwikkelworkflows.

Veelvoorkomende beperkingen van git stash

Net als de meeste Git-commando’s kent git stash beperkingen:

  • Het is geen vervanging voor commits.
  • Stashes zijn lokaal en worden niet gedeeld tussen repositories.
  • Untracked en genegeerde bestanden worden standaard niet gestasht.

Zo gebruikt u git stash

Wijzigingen stashen in Git is eenvoudig. Gebruik gewoon git stash in uw working directory. Dit commando stasht alle gewijzigde en gestagede wijzigingen en laat u achter met een schone working directory.

Uw wijzigingen stashen

  1. Breng wijzigingen aan in uw working directory.
  2. Voer git stash uit om de wijzigingen te stashen.
  3. De working directory keert terug naar de staat van de meest recente commit.

Wijzigingen stashen met een bericht

Gebruik git stash push -m “bericht” om uw stashes van een bericht te voorzien. Dat helpt bij het ordenen en herkennen van stashes, zeker wanneer u met meerdere stashes werkt.

Uw stashes bekijken

Gebruik git stash list. Dit commando toont een lijst van alle stashes, elk met een identifier en het bericht (als dat is opgegeven).

Untracked bestanden meenemen

Standaard stasht git stash alleen tracked bestanden of bestanden die aan de index zijn toegevoegd. Gebruik git stash --include-untracked of git stash -u om untracked bestanden te stashen.

Specifieke bestanden stashen

Wilt u alleen bepaalde bestanden of mappen stashen, gebruik dan git stash push -m “bericht” --path/to/file1 path/to/file2. Dit commando komt goed van pas wanneer u losse wijzigingen in verschillende bestanden of mappen wilt aanbrengen en onafhankelijk van elkaar wilt beheren.

Geselecteerde wijzigingen stashen

Met git stash -p selecteert u specifieke wijzigingen om te stashen, waardoor u meer grip hebt op wat er gestasht wordt.

Zo past u git-stashes toe

De laatste stash toepassen

git stash apply past de meest recente stash opnieuw toe en bewaart die in uw stashlijst.

De laatste stash toepassen en verwijderen

git stash pop zet uw gestashte wijzigingen terug en verwijdert ze definitief uit uw lijst.

Een specifieke stash toepassen

Wilt u een specifieke stash uit meerdere opgeslagen stashes toepassen, toon ze dan met git stash list en pas de gewenste stash toe via de identifier: git stash apply stash@{n}.

Veelvoorkomende problemen met git stash oplossen

Conflicten bij het toepassen van een stash oplossen

  • Probleem: conflicten bij het toepassen van een stash door overlappende wijzigingen.
  • Oplossing: los de conflicten handmatig op in de betrokken bestanden en voer daarna git add uit en commit ze.

Omgaan met stashes in een detached HEAD-staat

  • Probleem: stashes toepassen nadat u in een detached HEAD-staat hebt gewerkt.
  • Oplossing: check de gewenste branch uit en pas de stash daarna toe met git stash apply of git stash pop.

Dubbele stashes voorkomen

  • Probleem: dubbele stashes nadat u ze hebt toegepast zonder ze te droppen.
  • Oplossing: gebruik na het toepassen van een stash git stash drop om die te verwijderen als u hem niet meer nodig hebt.

Zo beheert en verwijdert u git-stashes

Een specifieke stash verwijderen

Met git stash drop stash@{n} verwijdert u specifieke stashes.

Alle stashes verwijderen

git stash clear verwijdert alle stashes die u hebt gemaakt.

Een gedropte stash terughalen

Hebt u per ongeluk een stash gedropt, gebruik dan git reflog om de commit-hash te vinden en pas die daarna opnieuw toe met git stash apply <commit-hash>.

De beste strategieën voor stashbeheer

  • Gebruik beschrijvende stashberichten: voeg aan elke stash die u maakt een duidelijke notitie toe, zodat u bij het doornemen van uw stashlijst snel ziet wat erin zit.
  • Stash wijzigingen voordat u van branch wisselt: stash uw wijzigingen eerst voordat u naar een andere branch overstapt, zodat uw working directory schoon blijft.
  • Beoordeel en ruim overbodige stashes regelmatig op: pas stashes toe of drop ze zodra u ze niet meer nodig hebt, zodat uw stashlijst overzichtelijk blijft.
  • Gebruik commits voor wijzigingen op de lange termijn: stashes als permanente opslag gebruiken, maakt het op termijn lastig om wijzigingen bij te houden en te beheren. Gebruik in plaats daarvan commits om belangrijk werk te bewaren en wijzigingen makkelijker te beoordelen of terug te zetten.

Geavanceerde git stash-commando’s

Hieronder staan enkele geavanceerde git stash-commando’s voor zowel gangbare als meer gespecialiseerde use cases:

Gestagede wijzigingen behouden

Normaal gesproken zijn de wijzigingen die bij het maken van de stash gestaged waren, niet meer gestaged wanneer u een stash toepast. Met git stash apply --index past u de stash opnieuw toe én staget u de wijzigingen die op het moment van stashen gestaged waren.

Een branch maken vanuit een stash

Hoort een stash eigenlijk op een aparte branch thuis, dan maakt het commando git stash branch new_branch_name stash@{n} een nieuwe branch vanaf de commit waarop de stash is gemaakt, past het de recente wijzigingen daarop toe en dropt het vervolgens de stash.

Dat is een uitstekende manier om gestashte wijzigingen te beheren die zijn uitgegroeid tot een omvangrijkere functie of bugfix.

Veelvoorkomende beperkingen van git stash

  • Het is geen vervanging voor commits.
  • Stashes zijn lokaal en worden niet gedeeld tussen repositories.
  • Untracked en genegeerde bestanden worden standaard niet gestasht.

Geavanceerde git stash-technieken

Specifieke bestanden of wijzigingen stashen

Gebruik git stash push [file1] [file2] om specifieke bestanden te stashen. Dit richt zich uitsluitend op de opgegeven bestanden of wijzigingen en geeft u fijnmaziger grip op wat er gestasht wordt.

Conflicten afhandelen bij het toepassen van gestashte wijzigingen

Bij het toepassen van stashes kunnen conflicten ontstaan. Pak ze aan zoals u een mergeconflict aanpakt: bewerk de bestanden om de conflicten op te lossen en voeg ze daarna toe en commit ze.

Git stash helpt bij het wisselen van branch

  • Stash de wijzigingen in de huidige branch.
  • Schakel over naar de doelbranch.
  • Pas de stash toe op de nieuwe branch.

Beste praktijken voor git stash

Net als bij veel andere ontwikkelprocessen zijn er ook voor git stash strategieën waarmee ontwikkelaars de krachtige mogelijkheden optimaal benutten. Dit zijn enkele beste praktijken voor git stash:

Gebruik stash met mate: met andere woorden: overdrijf het gebruik van git stash niet. Gebruik in plaats van stashen liever aparte branches voor werk in uitvoering op de lange termijn. Zet het commando met mate in, zeker wanneer u het alleen nodig hebt om aan een andere taak te werken, omdat het invloed heeft op de wijzigingen die bij het committen moeten worden doorgevoerd.

Gebruik duidelijke, beschrijvende stashberichten: ontwikkelaars kunnen een beschrijvend bericht toevoegen over de wijzigingen die ze stashen. Wees daarbij altijd duidelijk in uw stashberichten en vermijd overbodige berichten. Een betekenisvolle en informatieve stash helpt ontwikkelaars zich later precies te herinneren wat erin zit. Duidelijke berichten maken het bovendien makkelijker om later de juiste stash te herkennen en toe te passen, wat het terughalen vergemakkelijkt.

Benut branches: zorg er altijd voor dat er een nieuwe branch wordt gemaakt voordat u wijzigingen stasht. Zo schakelt u over naar andere taken of branches zonder uw huidige wijzigingen te raken. Daarna keert u terug naar de branch en past u de stash toe wanneer u weer aan de aanpassingen wilt werken.

Stash untracked bestanden: een van de beste praktijken die ontwikkelaars altijd zouden moeten volgen, is het gebruik van commando’s die untracked bestanden stashen. Dat verkleint het risico op gegevensverlies of op belangrijke wijzigingen die verloren gaan.

Beheer meerdere stashes: Commando’s stellen ontwikkelaars in staat meerdere stashes effectief te beheren. Denk aan git stash list om alle bestaande stashes te bekijken, git stash apply stash@{<n>} (waarbij <n> de index van de stash is) om een specifieke stash toe te passen en git stash drop stash@{<n>} (waarbij <n> de index van de stash is) om een stash te verwijderen wanneer u die niet meer nodig hebt.

Ga zorgvuldig om met stash pop: net als bij de eerste beste praktijk geldt dat u het commando stash pop (git stash pop) met gezond verstand moet gebruiken. Het commando biedt een snelle manier om een stash toe te passen en te verwijderen, maar de bewerking kan conflicten veroorzaken wanneer de gestashte wijzigingen botsen met de huidige working tree. U kunt ook het commando git stash apply gebruiken om de stash toe te passen zonder die te verwijderen. Zo lost u eventuele conflicten handmatig op voordat u de stash met git stash drop verwijdert.

Voer de wijzigingen zo snel mogelijk door: stashen hoort alleen een tijdelijke oplossing te zijn. Zodra u een reeks wijzigingen hebt afgerond, commit u die naar de repository om een vastlegging van de wijzigingen te bewaren.

Andere nuttige git stash-strategieën

Zo houdt u een schone Git-historie

  • Commit voor duurzaamheid: geef bij blijvende wijzigingen de voorkeur aan commits boven stashes.
    • git commit -m “Commitbericht”
  • Stashonderhoud: ruim stashes regelmatig op.
    • git stash list, gevolgd door git stash drop stash@{n}
  • Tijdelijke opslagplaats: gebruik stashes voor tijdelijke wijzigingen, niet voor wijzigingen op de lange termijn.

Veelvoorkomende valkuilen bij git stash

  • Vermijd overmatig stashen: te veel leunen op stash voor belangrijke wijzigingen.
  • Vergeet niet te unstashen: vergeten stashes toe te passen of te droppen.
    • git stash apply of git stash pop
  • Houd overzicht over uw stashes: niet meer weten wat elke stash bevat.
    • git stash list om stashes te bekijken
  • Schep duidelijkheid met opmerkingen: verwarrende stashes door te summiere stashopmerkingen.
    • git stash save “Beschrijvend bericht”

Git stash gebruiken in teamprojecten

  • Communiceer over uw stashes: meld gestashte wijzigingen die invloed kunnen hebben
  • Betere workflow: gebruik stashes om uw persoonlijke workflow te verbeteren.
  • Houd stashes lokaal: push stashes niet naar gedeelde repositories, tenzij er vanuit een stash een nieuwe branch moet worden gemaakt om lokale wijzigingen zo soepel mogelijk naar de repository te committen.

Git stash, git commit, git reset en git stage: wat zijn de verschillen?

Nu we git stash hebben besproken, kijken we hoe het verschilt van andere Git-commando’s, zoals commit, reset en stage.

Git commit

Git commit is een commando waarmee ontwikkelaars wijzigingen in de broncode opslaan en in de lokale repository bewaren. Ze doen dat om een snapshot van een project op een bepaald moment te bewaren, zodat ze een referentie hebben die de huidige staat van het project weerspiegelt, inclusief gestagede wijzigingen, op het moment dat ze eraan werkten. Ter verduidelijking vindt u hieronder een tabel met de verschillen:

Git reset

Git reset is een commando dat git stash aanvult en waarmee u wijzigingen in een Git-repository beheert. Door beide commando’s te combineren halen ontwikkelaars geback-upte en eerder verwijderde bestanden terug en zetten ze die terug in de repository. Maar git stash en git commit verschillen ook van elkaar, zoals u in de tabel hieronder ziet:

Git stage

Git stage wordt gebruikt om wijzigingen voor te bereiden op een commit. Daarbij worden de wijzigingen toegevoegd aan de staging area of “index”, zodat ontwikkelaars ze kunnen nakijken voordat ze committen.

De tabel hieronder toont de belangrijkste verschillen tussen git stash, git commit, git reset en git stage:

FunctieGit StashGit CommitGit ResetGit Stage
DoelSlaat niet-gecommitte wijzigingen tijdelijk opSlaat wijzigingen permanent op in de projecthistorieZet de huidige HEAD terug naar een specifieke staatBereidt wijzigingen voor op een commit
OmkeerbaarheidKan later worden toegepast of gedroptVereist git revert of git reset om ongedaan te makenKan ongedaan worden gemaakt met git reflog, maar kan destructief zijnStaging area
GegevensverliesKan van branch wisselen zonder te committenHeeft geen invloed op branchenKan niet-gecommitte wijzigingen verliezen (afhankelijk van de opties)Vereist git commit om te committen
BranchenEr kunnen meerdere stashes worden gemaaktCommits zijn lineairKan de branch wijzigen of een nieuwe makenWijzigingen kunnen worden ge-unstaged met git reset HEAD <file>

Wilt u van branch wisselen zonder voortgang te verliezen? Bekijk hoe u git stash gebruikt.

Stashen kweekt goede ontwikkelgewoonten

Door niet-gecommitte wijzigingen regelmatig te stashen, houden ontwikkelaars hun codebase schoon en geordend, wat de kans op conflicten en fouten verkleint. Verstandig toegepast verhoogt deze gewoonte de efficiëntie en effectiviteit van versiebeheer aanzienlijk.

Deze functie is niet zomaar een commando in het uitgebreide arsenaal van Git: het is een cruciaal gereedschap voor efficiënte en flexibele ontwikkelworkflows. Doordat u werk in uitvoering tijdelijk opzij kunt zetten, houdt u een schone working directory – essentieel in complexe softwareontwikkelomgevingen waar focus en organisatie doorslaggevend zijn.

De veelzijdigheid van git stash zit in de eenvoud en het brede scala aan situaties waarvoor het geschikt is – van snel van context wisselen tot experimenteren met nieuwe functies zonder de hoofdcodebase te verstoren. Die functionaliteit is vooral waardevol wanneer meerdere ontwikkelaars samen aan hetzelfde project bijdragen.

Stashes zorgen ervoor dat het werk van elke ontwikkelaar intact blijft en niet wordt geraakt door wijzigingen van anderen, wat een soepelere en productievere samenwerking oplevert.

Of u nu een beginnend programmeur bent die net met Git start of een ervaren ontwikkelaar: git stash vaardig kunnen gebruiken is een onmisbare vaardigheid in uw gereedschapskist voor softwareontwikkeling. Het biedt een strategische manier om met wijzigingen in code om te gaan, sluit goed aan bij effectieve ontwikkelpraktijken en draagt uiteindelijk bij aan gestroomlijnder en wendbaarder projectmanagement.

FAQs

Niet helemaal. Git biedt geen directe manier om een gedropte stash terug te halen, omdat stashes lokaal zijn en nooit worden gecommit. Is de stash kort geleden gedropt, dan kunt u met git reflog de commit-hash opzoeken en die daarna opnieuw toepassen met git stash apply gevolgd door die hash.

Een stash kan onbeperkt blijven bestaan, want Git verwijdert stashes nooit uit zichzelf. De stash blijft maanden of zelfs jaren in uw lokale repository staan, zolang u die niet expliciet verwijdert.

Ja, in die zin dat git stash conceptueel werkt als een Last-in, First-Out (LIFO)-stack. Het verschil is dat git stash extra flexibiliteit biedt die traditionele stackdatastructuren niet hebben.

Ja, u kunt git stash pop in een andere branch gebruiken, omdat git stash een globale stack voor uw repository is. Het is niet gebonden aan de specifieke branch waarin u de stash oorspronkelijk hebt gemaakt.

Meer om te lezen

Klaar om de moeilijkste delen van IT te vereenvoudigen?