Arbeitsfortschritte zwischenspeichern

Einführung

Willkommen zurück, Git-Entdecker! Heute beschäftigen wir uns mit einer der nützlichsten Funktionen von Git zur Verwaltung Ihrer laufenden Arbeiten: dem Stash. Waren Sie schon einmal mitten in der Arbeit an einem Feature, als Sie plötzlich zu einer anderen Aufgabe wechseln mussten? Git Stash ist hier, um den Tag zu retten!

Stellen Sie sich Git Stash wie eine magische Schublade vor, in der Sie Ihre unfertige Arbeit vorübergehend verstauen können. Es ermöglicht Ihnen, schnell den Kontext zu wechseln, ohne halbfertige Arbeit committen zu müssen. Dies ist unglaublich nützlich, wenn Sie Branches wechseln, Updates ziehen oder eine dringende Fehlerbehebung durchführen müssen.

In diesem Lab werden wir untersuchen, wie Sie Git Stash verwenden, um Ihren Arbeitsfortschritt zu speichern, wie Sie gestashte Änderungen wieder anwenden, Branches aus Stashes erstellen, mehrere Stashes verwalten und Ihre Stashes aufräumen. Am Ende dieses Labs werden Sie ein mächtiges neues Werkzeug in Ihrem Git-Werkzeugkasten haben, das Ihren Workflow reibungsloser und flexibler macht.

Lassen Sie uns anfangen und die Power von Git Stash freischalten!

Einrichten Ihres Arbeitsbereichs

Bevor wir uns dem Stashing widmen, richten wir einen Arbeitsbereich zum Experimentieren ein. Wir erstellen ein neues Verzeichnis, initialisieren ein Git-Repository und fügen erste Inhalte hinzu.

Öffnen Sie Ihr Terminal und geben Sie diese Befehle ein:

cd ~/project
mkdir git-stash-lab
cd git-stash-lab
git init
echo "## Git Stash Lab" > README.md
git add README.md
git commit -m "Initial commit"

Lassen Sie uns aufschlüsseln, was diese Befehle bewirken:

1. cd ~/project: Wechselt in den Ordner "project" in Ihrem Home-Verzeichnis.
2. mkdir git-stash-lab: Erstellt ein neues Verzeichnis namens "git-stash-lab".
3. cd git-stash-lab: Wechselt in das neu erstellte Verzeichnis.
4. git init: Initialisiert ein neues Git-Repository im aktuellen Verzeichnis.
5. echo "## Git Stash Lab" > README.md: Erstellt eine neue Datei namens "README.md" mit dem Inhalt "## Git Stash Lab".
6. git add README.md: Vormerken der neuen Datei für den Commit.
7. git commit -m "Initial commit": Erstellt Ihren ersten Commit mit den vorgemerkten Änderungen.

Hervorragend! Wir haben nun ein Repository mit einem Commit. Überprüfen wir unseren Status:

git status

Sie sollten eine Meldung sehen, dass Ihr Working Tree sauber ist. Das bedeutet, wir sind bereit, mit Git Stash zu experimentieren!

Falls Probleme auftreten, stellen Sie sicher, dass Sie sich im richtigen Verzeichnis befinden und Git ordnungsgemäß auf Ihrem System installiert ist. Sie können Ihre Git-Installation mit git --version überprüfen.

Änderungen stashen

Nachdem unser Arbeitsbereich eingerichtet ist, erstellen wir einige Änderungen und lernen, wie man sie stasht.

Zuerst nehmen wir einige Änderungen an unserer README.md-Datei vor:

echo "This is a work in progress" >> README.md

Dieser Befehl hängt eine neue Zeile an unsere README.md-Datei an. Erstellen wir außerdem eine neue Datei:

echo "Some important notes" > notes.txt

Wenn wir nun git status ausführen, sehen wir, dass wir sowohl modifizierte als auch unversionierte (untracked) Dateien haben:

git status

Die Ausgabe sollte anzeigen, dass README.md modifiziert wurde und notes.txt unversioniert ist.

Stellen Sie sich vor, Sie müssten an diesem Punkt schnell zu einer anderen Aufgabe wechseln, sind aber noch nicht bereit, diese Änderungen zu committen. Hier kommt git stash ins Spiel!

Um Ihre Änderungen zu stashen, führen Sie aus:

git stash

Sie sollten eine Ausgabe ähnlich dieser sehen:

Saved working directory and index state WIP on master: 1234567 Initial commit

Wenn Sie nun erneut git status ausführen, werden Sie etwas Interessantes bemerken:

git status

Sie werden feststellen, dass README.md nicht mehr als modifiziert angezeigt wird, notes.txt jedoch immer noch als unversionierte Datei aufgeführt ist. Dies ist ein entscheidender Punkt bei git stash:

Wichtig: Standardmäßig stasht git stash nur:

1. Änderungen an bereits versionierten Dateien (Dateien, die Git bereits verfolgt)
2. Bereits vorgemerkte (staged) Änderungen

Unversionierte Dateien (wie unsere notes.txt) werden standardmäßig nicht in den Stash aufgenommen. Dieses Verhalten stellt sicher, dass Git nicht versehentlich neue Dateien versteckt, die Sie vielleicht gar nicht im Repository haben möchten.

Wenn Sie unversionierte Dateien in Ihren Stash aufnehmen möchten, können Sie die Option -u (oder --include-untracked) verwenden:

git stash -u

Nach Ausführung dieses Befehls werden sowohl die Änderungen an README.md als auch die neue Datei notes.txt gestasht.

Um zu sehen, was sich in Ihrem Stash befindet, nutzen Sie:

git stash list

Sie sollten ein oder zwei Stash-Einträge sehen, je nachdem, ob Sie die Option -u verwendet haben.

Drücken Sie q, um die Stash-Listenansicht zu verlassen.

Denken Sie daran: Stashing ist perfekt für schnelle Kontextwechsel. Es ist jedoch kein Ersatz für Commits in Ihrem langfristigen Workflow. Stashes sind als temporärer Speicher gedacht.

Gestashte Änderungen anwenden

Nachdem wir unsere Änderungen gestasht haben, lernen wir nun, wie wir sie zurückholen. Dafür gibt es zwei Hauptbefehle: git stash apply und git stash pop.

Beginnen wir mit git stash apply:

git stash apply

Nachdem Sie diesen Befehl ausgeführt haben, bemerken Sie vielleicht etwas Unerwartetes. Prüfen wir den Status:

git status

Die Ausgabe sollte in etwa so aussehen:

On branch master
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        notes.txt

nothing added to commit but untracked files present (use "git add" to track)

Überraschenderweise sehen Sie nur notes.txt als unversionierte Datei und keine Änderungen an README.md. Dieses Verhalten tritt auf, weil:

1. In Schritt 2 haben wir zuerst git stash ohne die Option -u verwendet, was nur die Änderungen an README.md gestasht hat.
2. Danach haben wir git stash -u verwendet, was die unversionierte Datei notes.txt gestasht hat (README.md war zu diesem Zeitpunkt bereits sauber durch den vorherigen Stash).
3. Wenn wir den Stash anwenden, wendet Git den neuesten Stash an (den mit -u erstellten), der nur notes.txt enthält. Daher sehen Sie keine Änderungen an README.md.

Um alle Änderungen zu sehen, einschließlich derer an README.md, können Sie Folgendes verwenden:

git stash apply stash@{1}

Wenn Sie den Status jetzt erneut prüfen, sollten Sie sowohl die Änderungen an README.md als auch notes.txt als unversionierte Datei sehen.

Diese Situation verdeutlicht einen wichtigen Aspekt bei der Arbeit mit Stashes: Die Reihenfolge, in der Sie Stashes erstellen und anwenden, beeinflusst das Ergebnis. Es ist immer ratsam, den Inhalt Ihrer Stashes zu prüfen, bevor Sie sie anwenden, insbesondere wenn Sie mit mehreren Stashes arbeiten.

Der Unterschied zwischen apply und pop besteht darin, dass apply die Änderungen im Stash behält, während pop sie nach dem Anwenden aus dem Stash entfernt.

git stash clear
git stash -u
git stash list

Wir leeren zuerst alle Stashes, um neu zu beginnen, stashen dann unsere Änderungen mit der Option -u, um unversionierte Dateien einzuschließen, und listen schließlich unsere Stashes auf, um die Erstellung zu verifizieren.

Lassen Sie uns unsere Änderungen erneut stashen und pop ausprobieren:

git stash pop

Sie sehen eine ähnliche Ausgabe wie zuvor, aber wenn Sie jetzt git stash list ausführen, sehen Sie, dass Ihr Stash leer ist.

Warum gibt es sowohl apply als auch pop? apply ist nützlich, wenn Sie dieselben gestashten Änderungen auf mehrere Branches anwenden möchten. pop wird häufiger verwendet, wenn Sie einfach die Arbeit am selben Branch wieder aufnehmen.

Einen Branch aus einem Stash erstellen

Manchmal stellen Sie fest, dass die Änderungen, die Sie gestasht haben, eigentlich in einen eigenen Branch gehören. Git macht dies mit dem Befehl git stash branch sehr einfach.

Zuerst erstellen wir einige neue Änderungen und stashen sie:

echo "Feature in progress" >> README.md
echo "More notes" >> notes.txt
git stash -u

Erstellen wir nun einen neuen Branch mit diesen Änderungen:

git stash branch feature-branch

Dieser Befehl erstellt einen neuen Branch namens "feature-branch", checkt ihn aus und wendet dann die gestashten Änderungen darauf an. Der Stash wird anschließend aus Ihrer Stash-Liste entfernt.

Die Ausgabe sollte in etwa so aussehen:

Switched to a new branch 'feature-branch'
On branch feature-branch
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   README.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        notes.txt

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (1234567890abcdef1234567890abcdef12345678)

Diese Funktion ist besonders nützlich, wenn Sie experimentelle Änderungen gestasht haben und später entscheiden, dass es sich lohnt, diese in einem eigenen Branch weiterzuverfolgen.

Denken Sie daran, dass Sie nach dem Erstellen eines Branches aus einem Stash die Änderungen committen müssen, wenn Sie sie behalten wollen:

git add README.md notes.txt
git commit -m "Start new feature"

Um zurück zu Ihrem Master-Branch zu wechseln, nutzen Sie:

git checkout master

Verwalten mehrerer Stashes

Während der Arbeit mit Git werden Sie vielleicht feststellen, dass Sie mehrere Sätze von Änderungen stashen. Git ermöglicht es Ihnen, mehrere Stashes einfach zu verwalten. Lassen Sie uns untersuchen, wie man mehrere Stashes erstellt, auflistet und verwaltet.

Zuerst erstellen wir drei Stashes mit unterschiedlichen Änderungen:

## Erster Stash
echo "Change 1" >> README.md
git stash push -m "First change"

## Zweiter Stash mit unversionierter Datei
echo "Change 2" >> README.md
echo "Note 2" >> notes.txt
git stash push -u -m "Second change"

## Dritter Stash
echo "Change 3" >> README.md
git stash push -m "Third change"

Hinweis: Sie werden bemerken, dass wir jetzt git stash push anstelle von nur git stash verwenden. Der Unterbefehl push ist der moderne, bevorzugte Weg, um Stashes zu erstellen, insbesondere wenn Sie mit dem Flag -m benutzerdefinierte Nachrichten hinzufügen möchten. Während git stash und git stash -u weiterhin funktionieren (sie sind Abkürzungen für git stash push bzw. git stash push -u), bietet die explizite Verwendung von git stash push mehr Kontrolle und Klarheit, besonders bei der Verwaltung mehrerer Stashes mit beschreibenden Nachrichten.

Lassen Sie uns zusammenfassen, was wir getan haben:

1. Erster Stash mit einer Änderung an README.md erstellt.
2. Zweiter Stash mit einer Änderung an README.md und einer neuen unversionierten Datei erstellt.
3. Dritter Stash mit einer weiteren Änderung an README.md erstellt.
4. Das Flag -m verwendet, um beschreibende Nachrichten hinzuzufügen.
5. Das Flag -u für den zweiten Stash verwendet, um die unversionierte Datei einzuschließen.

Listen wir nun unsere Stashes auf:

git stash list

Die Ausgabe sollte etwa so aussehen:

stash@{0}: On master: Third change
stash@{1}: On master: Second change
stash@{2}: On master: First change

Sie können den Inhalt eines Stashs untersuchen, ohne ihn anzuwenden:

git stash show stash@{1}

Für mehr Details fügen Sie das Flag -p hinzu, um den vollständigen Diff zu sehen:

git stash show -p stash@{1}

Erstellen wir zwei weitere Stashes, um den Umgang mit einer größeren Menge an Änderungen zu üben:

## Vierter Stash
echo "Change 4" >> README.md
git stash push -m "Fourth change"

## Fünfter Stash
echo "Change 5" >> README.md
git stash push -m "Fifth change"

Prüfen Sie Ihre Stash-Liste erneut:

git stash list

Sie sollten nun fünf Stashes in Ihrer Liste sehen:

stash@{0}: On master: Fifth change
stash@{1}: On master: Fourth change
stash@{2}: On master: Third change
stash@{3}: On master: Second change
stash@{4}: On master: First change

Die Verwaltung mehrerer Stashes kann nützlich sein, wenn Sie mehrere Aufgaben gleichzeitig jonglieren. Versuchen Sie jedoch, nicht zu viele Stashes anzuhäufen, da dies unübersichtlich werden kann. Erwägen Sie die Verwendung von Branches für längerfristige Arbeiten.

Denken Sie daran: Stashes sind als temporäre Lösung gedacht. Wenn Sie Stashes über einen langen Zeitraum behalten, sollten Sie stattdessen Feature-Branches verwenden oder Ihre Änderungen committen.

Aufräumen von Stashes

Wenn Sie Stashes in Ihren Workflow integrieren, sammeln sich mit der Zeit vielleicht Stashes an, die Sie nicht mehr benötigen. Es ist eine gute Praxis, Ihre Stashes regelmäßig aufzuräumen, um die Übersicht zu behalten.

Um einen einzelnen Stash zu entfernen, können Sie den drop-Befehl verwenden, den wir bereits kurz erwähnt haben:

git stash drop stash@{2}

Dies entfernt den dritten Stash (mit "Third change") aus unserer Liste.

Wenn Sie alle Ihre Stashes auf einmal entfernen möchten, können Sie diesen Befehl nutzen:

git stash clear

Seien Sie sehr vorsichtig mit diesem Befehl! Er entfernt alle Ihre Stashes unwiderruflich.

Ein weiterer nützlicher Befehl ist git stash pop, den wir bereits kennengelernt haben. Er wendet den neuesten Stash an und entfernt ihn anschließend aus der Liste:

git stash pop

Generell ist es ratsam, die Stash-Liste kurz zu halten. Stashes sind für die temporäre Speicherung von laufenden Arbeiten gedacht. Wenn Sie viele Stashes ansammeln, könnte das ein Zeichen dafür sein, dass Sie häufiger committen oder Feature-Branches für längerfristige Aufgaben erstellen sollten.

Zusammenfassung

Herzlichen Glückwunsch, Git-Stash-Meister! Sie haben gerade ein mächtiges neues Werkzeug in Ihren Git-Werkzeugkasten aufgenommen. Lassen Sie uns die wichtigsten Konzepte rekapitulieren:

1. Änderungen stashen: Sie haben gelernt, wie Sie Ihre laufende Arbeit mit git stash vorübergehend speichern.
2. Gestashte Änderungen anwenden: Sie haben entdeckt, wie Sie Ihre Änderungen mit git stash apply und git stash pop zurückholen.
3. Branches aus Stashes erstellen: Sie haben gesehen, wie man einen Satz gestashter Änderungen mit git stash branch in einen neuen Branch überführt.
4. Mehrere Stashes verwalten: Sie haben gelernt, mit mehreren Stashes zu arbeiten und gezielt bestimmte Stashes anzuzeigen oder anzuwenden.
5. Aufräumen von Stashes: Sie haben gute Stash-Hygiene geübt, indem Sie gelernt haben, einzelne Stashes zu löschen oder die gesamte Liste zu leeren.

Git Stash ist eine unglaublich nützliche Funktion, die es Ihnen ermöglicht, schnell den Kontext zu wechseln, ohne unfertige Arbeit committen zu müssen. Es ist perfekt für jene Momente, in denen Sie schnell Aufgaben oder Branches wechseln müssen.

Denken Sie daran: Stashes sind zwar nützlich, aber als temporäre Lösung gedacht. Für längerfristige Arbeiten ist es meist besser, Änderungen zu committen oder einen neuen Branch zu erstellen. Setzen Sie Stashes klug ein, und sie werden Ihnen helfen, Ihren Workflow reibungslos und flexibel zu gestalten.