Wat is git stash en wanneer gebruik je het?

Question

Accepted Answer

**git stash** slaat je uncommitted changes **tijdelijk op** en zet je working directory terug naar een schone staat — zodat je context kunt wisselen (bijv. een urgente bug op een ander branch fixen) zonder half-af werk te committen, en de changes later kunt herstellen.

## Het probleem dat stash oplost

```text
You're mid-work with uncommitted changes, but need to switch context urgently:
  → switch branches? Git may refuse (uncommitted changes would conflict) or carry
    them along messily
  → commit half-done work? No — it's not ready (pollutes history)
→ STASH saves your changes aside, giving you a clean working directory to switch.
```

## Stash gebruiken

```bash
git stash                      # save uncommitted changes; working dir becomes clean
git stash push -m "message"    # stash with a description
git stash list                 # list stashes (stash@{0}, stash@{1}, ...)

git stash pop                  # RESTORE the latest stash AND remove it from the list
git stash apply                # restore but KEEP it in the stash list
git stash apply stash@{1}      # apply a specific stash
git stash drop stash@{0}       # delete a stash
git stash clear                # remove all stashes
```

`git stash` slaat changes op en maakt de working directory schoon; `git stash pop` herstelt ze later (en verwijdert de stash). `apply` herstelt zonder te verwijderen.

## Veelvoorkomend scenario

```bash
# working on a feature, but an urgent bug needs fixing on main:
git stash                      # save the in-progress feature work
git switch main
# ... fix the urgent bug, commit, push ...
git switch feature
git stash pop                  # restore the feature work and continue
```

## Nuttige opties

```text
git stash -u        → also stash UNTRACKED files (not just tracked changes)
git stash show -p   → see what's in a stash
→ Stash is for TEMPORARY storage — not a substitute for commits/branches long-term.
```

## Waarom het belangrijk is

Inzicht in `git stash` is waardevol voor **schone context wissels**, een frequent scenario in de praktijk, dus het is bruikbare Git-kennis.

Het probleem dat het oplost komt veel voor: je bent midden in je werk met uncommitted changes als je opeens **context moet wisselen** (een productie bug op een ander branch fixen, iemands code reviewen, updates ophalen) — maar branches wisselen met uncommitted changes is problematisch (Git kan weigeren of ze rommelig meenemen), en half-af werk committen vervuilt je history. **Stash** lost dit elegant op door **je changes opzij te zetten** en je een schone working directory te geven om context te wisselen, en ze **later te herstellen** als je terugkomt — perfect voor het veelvoorkomende "ik moet even pauzeren met wat ik doe" scenario.

De kern commands begrijpen (`git stash` om op te slaan, `git stash pop` om te herstellen-en-verwijderen, `git stash apply` om te herstellen-en-te-behouden, `git stash list` om stashes te zien) en de typische workflow (work in progress stashen, wisselen en de urgente taak afhandelen, terugwisselen en poppen) is praktische dagelijkse kennis voor het beheren van onderbrekingen.

Nuttige opties kennen (`-u` voor untracked files, stash contents bekijken) en weten dat stash voor **tijdelijke** opslag is (niet als vervanging voor commits/branches) toont correct gebruik.

Omdat context wissels en onderbrekingen veel voorkomen in development (urgente bugs, reviews, behoefte aan schone working directory), en omdat stash een schone, handige manier biedt om uncommitted work tijdelijk opzij te zetten en later te herstellen, is inzicht in `git stash` — wat het oplost, de commands, en de veelvoorkomende context-switch workflow — waardevolle, praktische Git-kennis voor het afhandelen van de frequent voorkomende real-world behoefte om context te wisselen zonder onafgemaakt werk te committen, een handig hulpmiddel dat de veelvoorkomende onderbrekingen in je dagelijkse development gladstrijkt.