Vad är git stash och när använder du det?

Question

Accepted Answer

**git stash** sparar tillfälligt **dina ocommittade ändringar** och återställer din arbetskatalog till ett rent tillstånd — så att du kan växla kontext (t.ex. fixa en brådskande bugg på en annan branch) utan att commita halvfärdig kod, och sedan återställa ändringarna senare.

## Problemet som stash löser

```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.
```

## Använda stash

```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` sparar ändringar och rensar arbetskatalogen; `git stash pop` återställer dem senare (och tar bort stash). `apply` återställer utan att ta bort.

## Vanligt 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
```

## Användbara alternativ

```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.
```

## Varför det är viktigt

Att förstå `git stash` är värdefullt för **att hantera kontextväxlingar rent**, en vanlig situation i verkligheten, så det är användbar praktisk Git-kunskap.

Problemet det löser är frekvent: du är mitt i arbetet med ocommittade ändringar när du behöver **växla kontext brådskande** (fixa en produktionsbug på en annan branch, granska någons kod, hämta uppdateringar) — men att växla branches med ocommittade ändringar är problematiskt (Git kan vägra eller bära dem på ett rörigt sätt), och att commita halvfärdig kod förorenar historiken. **Stash** löser detta elegant genom att **spara dina ändringar åt sidan** och ge dig en ren arbetskatalog för att växla kontext, och sedan **återställa dem senare** när du återvänder — exakt passande för det vanliga scenariot "Jag behöver tillfälligt sluta med det jag gör".

Att förstå kärnkommandona (`git stash` för att spara, `git stash pop` för att återställa-och-ta-bort, `git stash apply` för att återställa-och-behålla, `git stash list` för att se stashes) och det typiska arbetsflödet (stasha pågående arbete, växla och hantera den brådskande uppgiften, växla tillbaka och pop) är praktisk daglig kunskap för att hantera avbrott.

Att känna till användbara alternativ (`-u` för att inkludera ospårade filer, visa stash-innehåll) och att stash är för **tillfällig** lagring (inte ett långsiktigt substitut för commits/branches) återspeglar korrekt användning.

Eftersom kontextväxlingar och avbrott är vanliga i utveckling (brådskande buggar, recensioner, behov av en ren arbetskatalog), och eftersom stash ger ett rent, bekvämt sätt att tillfälligt lägga åt sidan ocommittad kod och återställa den senare, är förståelse för `git stash` — vad det löser, kommandona och det vanliga kontextväxlingsarbetsflödet — värdefullt, praktiskt relevant Git-kunskap för att hantera det frekventa verkliga behovet att växla kontext utan att commita oferdig arbete, ett praktiskt verktyg som gör de vanliga avbrotten i daglig utveckling smidigare.