Git Stash erklärt: Änderungen sichern, wiederherstellen und verwalten

Was ist Git stash?

git stash ist ein Git-Befehl, der deine nicht committeten Änderungen vorübergehend „weglegt“, sodass du ohne Git-Commit zu einem sauberen Arbeitsverzeichnis zurückkehren kannst. So wechselst du bequem den Branch oder kümmerst dich um Dringendes, ohne Fortschritt zu verlieren.

Stashes werden in einem LIFO-Stack (Last-in, First-out) gespeichert. Der neueste Stash ist immer stash@{0}, gefolgt von stash@{1} usw.

Standardmäßig speichert git stash geänderte, verfolgte Dateien und gestagte Änderungen (aus dem Index). Neue, unverfolgte Dateien sowie ignorierte Dateien, etwa aus .gitignore, sind nicht enthalten.

Änderungen mit git stash sichern

In diesem Abschnitt zeige ich dir drei gängige Wege, Änderungen zu stashen. Unser durchgängiges Beispiel: Du arbeitest an einem Datenpipeline-Projekt mit den Dateien data_pipeline.py, config.yaml und tests/test_pipeline.py.

Verfolgte Änderungen stashen

Da git stash geänderte oder gestagte Änderungen speichert, prüfe mit git status den Status der Dateien in deinem Arbeitsverzeichnis. Nach git stash werden sowohl gestagte als auch ungestagte verfolgte Änderungen gesichert, und du hast ein aufgeräumtes Arbeitsverzeichnis.

Unverfolgte Änderungen und neue Dateien einbeziehen

Standardmäßig ignoriert git stash Dateien, die noch nie dem Repository hinzugefügt wurden. Wenn du eine neue Testdatei erstellt hast, bleibt sie nach einem normalen Stash im Verzeichnis liegen – das kann beim Branch-Wechsel stören.

Wenn du git stash ausführst, bleibt diese Datei bestehen. Um sie einzubeziehen, nutze den Schalter -u bzw. --include-untracked:

git stash -u

Um wirklich alle Dateien einzuschließen – auch jene, die in .gitignore explizit ignoriert werden –, kannst du git stash --all bzw. -a verwenden. Sei dabei jedoch vorsichtig, da so auch Logs oder Build-Artefakte unbeabsichtigt mitgenommen werden können.

Deinen Stash benennen

Bei git stash werden Standardmeldungen wie WIP on main schnell unübersichtlich, wenn du mehrere Stashes hast. Vermeide das, indem du beim Pushen der Stashes immer eine aussagekräftige Nachricht ergänzt.

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

Mit git stash list kannst du dir die Stash-Liste anzeigen lassen und vergleichen. Achte auf den Unterschied zwischen benannten und Standard-Stashes.

Klare Nachrichten machen es viel einfacher, später den richtigen Stash zu finden – besonders, wenn du mehrere Aufgaben parallel jonglierst oder im Team arbeitest.

Ich empfehle dir unsere Lernpfade GitHub Foundations und Git Fundamentals, um Versionskontrolle mit Git vom Einstieg bis zu fortgeschrittenen Workflows zu lernen – inklusive Änderungen nachverfolgen, Repositories managen und effizient zusammenarbeiten.

Stashes anzeigen und prüfen

Bevor du einen Stash blind anwendest, solltest du prüfen, was drinsteckt. Dieser Schritt wird oft übersprungen, verhindert aber Verwirrung oder versehentliches Überschreiben.

git stash list: Alle Stashes auflisten

Nutze diesen Befehl, um deinen Stash-Stack zu sehen:

git stash list

Wie du nun weißt, folgen Stashes einer LIFO-Reihenfolge. Der neueste Stash ist immer stash@{0}, jeder neue Stash schiebt die älteren weiter nach unten im Stack.

git stash show: Stash vor dem Anwenden inspizieren

Für eine schnelle Zusammenfassung der Änderungen in einem Stash kannst du show für einen bestimmten Stash nutzen. Der folgende Befehl zeigt z. B. die Änderungen im neuesten Stash:

git stash show stash@{0}

Um die tatsächlichen Codeänderungen (den kompletten Diff) zu sehen, nutze den folgenden Befehl, um alle zeilenweisen Änderungen dieses Stashs anzuzeigen.

git stash show -p stash@{0}

Als Best Practice solltest du einen Stash immer erst inspizieren, besonders wenn er ein paar Tage alt ist oder du nicht genau weißt, was er enthält.

Stashed-Änderungen wiederherstellen

Sobald du deine Arbeit mit git stash gesichert hast, brauchst du einen Weg, sie zurückzuholen. Es gibt zwei Hauptmethoden zum Wiederherstellen – inklusive gezieltem Anwenden per Index.

git stash pop: Anwenden und entfernen

Das ist der gängigste Weg. Er nimmt den obersten Stash (stash@{0}), wendet die Änderungen auf deinem aktuellen Branch an und löscht den Stash anschließend aus dem Stack.

git stash pop

Nach pop sind deine Änderungen wiederhergestellt und der Stash ist entfernt. Nutze pop, wenn du sicher bist, dass du diesen Stand nicht mehr brauchst und deine Stash-Liste schlank halten willst.

Für ein tieferes Verständnis von pop empfehle ich unser Tutorial Git Stash Pop – dort lernst du, wie du bei Branch-Wechseln in deinem Repo uncommittete Arbeit sicherst.

git stash apply: Anwenden und behalten

Wenn du Änderungen wiederherstellen, den Stash aber zur Wiederverwendung behalten willst, nutze apply wie folgt:

git stash apply stash@{1}

Die Referenz per Index stash@{1} zielt auf genau diesen Stash. Das ist praktisch, wenn du dieselben Änderungen in mehreren Branches anwenden willst, z. B. einen gemeinsamen Config-Tweak in main und staging.

Mit git stash list kannst du prüfen, ob der Stash nach apply noch vorhanden ist.

Selektiv stashen

In echten Projekten sind Änderungen oft vermischt. Dann möchtest du vielleicht nur einen Teil weglegen und den Rest verfügbar halten. Git bietet dafür zwei Methoden mit feiner Kontrolle.

git stash push -m: Bestimmte Dateien stashen

Wenn du genau weißt, welche Dateien beiseitegelegt werden sollen, kannst du Pfade angeben und nur ausgewählte Dateien stashen:

Der folgende Befehl stash’t beispielsweise nur data_pipeline.py. Das ist hilfreich, wenn du eine experimentelle Funktion pausieren willst, während ein Bugfix gestagt bleibt und bereit zum Commit ist.

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

Mit git status kannst du prüfen, ob der Befehl erfolgreich war – vor und nach dem Stash.

git stash push -p -m: Bestimmte Hunks interaktiv stashen

Manchmal stecken „guter“ Code und „WIP“-Code in derselben Datei. Nutze in dem Fall -p bzw. --patch für eine interaktive Session. So wählst du gezielt bestimmte Blöcke („Hunks“) innerhalb einer Datei aus.

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

Du siehst dann „Stash this hunk“ mit folgenden Optionen:

• y: Ja, diesen Hunk stashen

• n: Nein, diesen Hunk überspringen

• q: Beenden; diesen und alle verbleibenden Hunks nicht stashen

• a: Alle; diesen und alle folgenden Hunks in der Datei stashen

• d: Löschen; diesen und alle folgenden Hunks in der Datei nicht stashen

• ?: Hilfe

Dieser Ablauf ähnelt stark git add -p. Er ist hilfreich, wenn Änderungen in derselben Datei unabhängig sind und getrennt behandelt werden sollten.

Deinen Stash aufräumen

Stashes sind kurzlebig gedacht. Wenn sie sich stapeln, wird die Suche später mühsam und das Konfliktrisiko steigt, sobald du sie anwendest.

git stash drop: Einen bestimmten Stash entfernen

Um einen einzelnen Stash zu löschen, verwende git stash drop mit seinem Index. Der folgende Befehl entfernt z. B. den vierten Stash in der Liste.

git stash drop stash@{3}

Wie im Beispiel zu sehen, wird die Liste verkleinert und die verbleibenden Stashes nach dem Drop neu indexiert.

git stash clear: Alle Stashes leeren

Um alle Stashes auf einmal zu entfernen, nutze:

git stash clear

Dieser Befehl gibt bei Erfolg keine Ausgabe zurück. Prüfen kannst du es mit git stash list.

Sei bei git stash clear besonders vorsichtig – die Aktion ist endgültig und es gibt kein eingebautes Undo. Führe sie nur aus, wenn du sicher bist, dass du keinen Stash mehr brauchst.

git stash branch: Einen Stash in einen Branch umwandeln

Wenn sich dein aktueller Branch seit Erstellung des Stashs stark verändert hat, kann das Anwenden zu Merge-Konflikten führen. In dem Fall kannst du direkt aus dem Stash einen neuen Branch erstellen:

git stash branch pipeline-fix stash@{1}

Der obige Befehl macht Folgendes:

• Erstellt einen neuen Branch aus dem ursprünglichen Commit, an dem der Stash entstanden ist
• Wendet den Stash an
• Entfernt ihn aus der Stash-Liste

Mehr zum Branch-Management für bessere Entwicklung und Zusammenarbeit findest du im Tutorial Git Branch.

Weitere nützliche Git-Stash-Befehle

Neben den gängigen Workflows sind dies einige fortgeschrittene git stash-Befehle, die du kennen solltest:

• git stash create: Erstellt ein Stash-Objekt, ohne es der Stash-Liste hinzuzufügen

• git stash store: Speichert einen mit create erzeugten Stash

• git stash export: Exportiert einen Stash an eine Referenz oder gibt ihn aus

• git stash import: Importiert einen Stash aus einem bestehenden Commit

Häufige Fehler und wie du sie behebst

Auch wenn git stash simpel ist, gibt es ein paar Stolperfallen. Hier sind häufige Probleme, die mir begegnet sind – samt Erkennung und schneller Lösung.

No local changes to save

Der häufigste „Nicht-Fehler“. Er tritt auf, wenn du git stash in einem sauberen Arbeitsverzeichnis ausführst, in dem es keine geänderten oder gestagten verfolgten Dateien gibt.

Lösung: Führe git status aus. Wenn nichts angezeigt wird, gibt es nichts zu stashen.

Konflikt beim Anwenden eines Stashs

Konflikte entstehen, wenn im aktuellen Branch dieselben Codezeilen geändert wurden wie in deinem Stash. Beispiel: Nach einer Änderung in der Datei führst du git stash pop auf einem neuen Branch aus und erhältst eine Fehlermeldung:

Anschließend siehst du Konfliktmarker in der Datei:

So behebst du das Problem:

• Konflikte in der Datei manuell auflösen
• Aufgelöste Dateien stagen

git add data_pipeline.py

• Stash manuell mit git stash drop entfernen (falls er bei Konflikt NICHT automatisch gelöscht wurde)

Wenn die Konflikte zu unübersichtlich sind, wende die Änderungen stattdessen auf einer sauberen Basis an:

git stash branch recovery-branch stash@{0}

Aus Versehen Dateien gestasht, die nicht weg sollten

Manchmal führst du git stash aus, ohne dein Arbeitsverzeichnis zu prüfen – und merkst später, dass du einen Fix versteckt hast, den du eigentlich committen wolltest.

Um das zu vermeiden, gib beim Stashen explizit Dateien an. Der folgende Befehl stash’t z. B. nur data_pipeline.py statt alles im Arbeitsverzeichnis.

git stash push data_pipeline.py

Du kannst auch git stash -p nutzen, um den interaktiven (Patch-)Modus zu starten und gezielt Teile von Änderungen innerhalb von Dateien zu stashen – nicht ganze Dateien.

Als Vorsichtsmaßnahme: Prüfe immer git status, bevor du stashst.

Fazit

Als Faustregel: Halte Stashes kurzlebig und nutze aussagekräftige Nachrichten. Wenn du nicht innerhalb eines Tages zurückkehrst, ist ein WIP-Branch oft die solidere Option – er lässt sich ins Remote pushen und geht nicht verloren.

Um deine Git-Kompetenzen auszubauen, empfehle ich unseren Kurs Intermediate Git für Zusammenarbeit mit Git. Außerdem unseren Kurs Advanced Git – dort lernst du, wie du Git in großen Projekten einsetzt und komplexe Versionskontrollszenarien und -probleme in der Datenpipeline-Entwicklung meisterst.