English ▾ Themen ▾ Neueste Version ▾ git-reset zuletzt aktualisiert in 2.52.0

NAME

git-reset - Setzt den aktuellen HEAD auf den angegebenen Zustand zurück

SYNOPSIS

git reset [-q] [<tree-ish>] [--] <pathspec>…​
git reset [-q] [--pathspec-from-file=<file> [--pathspec-file-nul]] [<tree-ish>]
git reset (--patch | -p) [<tree-ish>] [--] [<pathspec>…​]
git reset [--soft | --mixed [-N] | --hard | --merge | --keep] [-q] [<commit>]

BESCHREIBUNG

In den ersten drei Formen werden Einträge aus <tree-ish> in den Index kopiert. In der letzten Form wird der aktuelle Branch-Kopf (HEAD) auf <commit> gesetzt, wobei der Index und der Arbeitsbaum optional angepasst werden. Das <tree-ish>/<commit> ist in allen Formen standardmäßig HEAD.

git reset [-q] [<tree-ish>] [--] <pathspec>...
git reset [-q] [--pathspec-from-file=<file> [--pathspec-file-nul]] [<tree-ish>]

Diese Formen setzen die Indexeinträge für alle Pfade, die mit dem <pathspec> übereinstimmen, auf ihren Zustand in <tree-ish> zurück. (Sie beeinträchtigen den Arbeitsbaum oder den aktuellen Branch nicht.)

Das bedeutet, dass git reset <pathspec> das Gegenteil von git add <pathspec> ist. Dieser Befehl ist äquivalent zu git restore [--source=<tree-ish>] --staged <pathspec>....

Nachdem Sie git reset <pathspec> ausgeführt haben, um den Indexeintrag zu aktualisieren, können Sie git-restore[1] verwenden, um den Inhalt vom Index in den Arbeitsbaum auszuchecken. Alternativ können Sie mit git-restore[1] und Angabe eines Commits mit --source den Inhalt eines Pfades aus einem Commit in den Index und den Arbeitsbaum in einem Schritt kopieren.

git reset (--patch | -p) [<tree-ish>] [--] [<pathspec>...]

Wählt interaktiv Hunks in der Differenz zwischen dem Index und <tree-ish> (standardmäßig HEAD). Die ausgewählten Hunks werden umgekehrt auf den Index angewendet.

Das bedeutet, dass git reset -p das Gegenteil von git add -p ist, d. h. Sie können es verwenden, um Hunks selektiv zurückzusetzen. Lesen Sie den Abschnitt "Interaktiver Modus" in git-add[1], um zu erfahren, wie der --patch-Modus bedient wird.

git reset [<mode>] [<commit>]

Diese Form setzt den aktuellen Branch-Kopf auf <commit> zurück und aktualisiert möglicherweise den Index (setzt ihn auf den Baum von <commit>) und den Arbeitsbaum, abhängig von <mode>. Vor der Operation wird ORIG_HEAD auf die Spitze des aktuellen Branches gesetzt. Wenn <mode> weggelassen wird, ist der Standardwert --mixed. Der <mode> muss einer der folgenden sein

--soft

Berührt die Indexdatei oder den Arbeitsbaum überhaupt nicht (setzt aber den Kopf auf <commit> zurück, wie alle Modi). Dies lässt alle Ihre geänderten Dateien als "Changes to be committed" (zu committende Änderungen), wie git status sie anzeigen würde.

--mixed

Setzt den Index zurück, aber nicht den Arbeitsbaum (d. h. die geänderten Dateien bleiben erhalten, sind aber nicht zum Commit markiert) und meldet, was nicht aktualisiert wurde. Dies ist die Standardaktion.

Wenn -N angegeben ist, werden entfernte Pfade als "intent-to-add" markiert (siehe git-add[1]).

--hard

Setzt den Index und den Arbeitsbaum zurück. Alle Änderungen an nachverfolgten Dateien im Arbeitsbaum seit <commit> werden verworfen. Alle nicht nachverfolgten Dateien oder Verzeichnisse, die beim Schreiben von nachverfolgten Dateien im Weg sind, werden einfach gelöscht.

--merge

Setzt den Index zurück und aktualisiert die Dateien im Arbeitsbaum, die sich zwischen <commit> und HEAD unterscheiden, behält aber diejenigen, die sich zwischen Index und Arbeitsbaum unterscheiden (d. h. die Änderungen enthalten, die nicht hinzugefügt wurden). Wenn eine Datei, die sich zwischen <commit> und dem Index unterscheidet, ungespeicherte Änderungen aufweist, wird der Reset abgebrochen.

Mit anderen Worten, --merge führt etwas aus wie git read-tree -u -m <commit>, trägt aber nicht zusammengeführte Indexeinträge weiter.

--keep

Setzt Indexeinträge zurück und aktualisiert Dateien im Arbeitsbaum, die sich zwischen <commit> und HEAD unterscheiden. Wenn eine Datei, die sich zwischen <commit> und HEAD unterscheidet, lokale Änderungen aufweist, wird der Reset abgebrochen.

--recurse-submodules
--no-recurse-submodules

Wenn der Arbeitsbaum aktualisiert wird, setzt --recurse-submodules auch rekursiv den Arbeitsbaum aller aktiven Submodule entsprechend dem im Superprojekt aufgezeichneten Commit zurück und setzt auch den HEAD der Submodule auf detached an diesem Commit.

Siehe "Zurücksetzen, Wiederherstellen und Rückgängigmachen" in git[1] für die Unterschiede zwischen den drei Befehlen.

OPTIONEN

-q
--quiet

Seien Sie ruhig, melden Sie nur Fehler.

--refresh
--no-refresh

Aktualisiert den Index nach einem Mixed-Reset. Standardmäßig aktiviert.

--pathspec-from-file=<file>

Pathspec wird in <file> anstelle von Kommandozeilenargumenten übergeben. Wenn <file> genau - ist, wird die Standardeingabe verwendet. Pathspec-Elemente werden durch LF oder CR/LF getrennt. Pathspec-Elemente können wie für die Konfigurationsvariable core.quotePath erklärt (siehe git-config[1]) in Anführungszeichen gesetzt werden. Siehe auch --pathspec-file-nul und global --literal-pathspecs.

--pathspec-file-nul

Nur relevant mit --pathspec-from-file. Pfadangaben werden durch ein NUL-Zeichen getrennt und alle anderen Zeichen werden wörtlich genommen (einschließlich Zeilenumbrüchen und Anführungszeichen).

-U<n>
--unified=<n>

Generiert Diffs mit <n> Zeilen Kontext. Standard ist diff.context oder 3, wenn die Konfigurationsoption nicht gesetzt ist.

--inter-hunk-context=<n>

Zeigt den Kontext zwischen Diff-Hunks bis zur angegebenen Anzahl von <n> Zeilen an und fasst so nahe beieinander liegende Hunks zusammen. Standard ist diff.interHunkContext oder 0, wenn die Konfigurationsoption nicht gesetzt ist.

--

Interpretiere keine weiteren Argumente mehr als Optionen.

<pathspec>...

Begrenzt die von der Operation betroffenen Pfade.

Weitere Details finden Sie im Eintrag pfadspec in gitglossary[7].

BEISPIELE

Hinzufügen rückgängig machen
$ edit                                     (1)
$ git add frotz.c filfre.c
$ mailx                                    (2)
$ git reset                                (3)
$ git pull git://info.example.com/ nitfol  (4)
  1. Sie arbeiten fleißig an etwas und stellen fest, dass die Änderungen in diesen Dateien in Ordnung sind. Sie möchten sie nicht sehen, wenn Sie git diff ausführen, da Sie an anderen Dateien arbeiten und Änderungen an diesen Dateien ablenkend sind.

  2. Jemand bittet Sie um einen Pull, und die Änderungen klingen vielversprechend.

  3. Sie haben jedoch bereits den Index "beschmutzt" (d. h. Ihr Index stimmt nicht mit dem HEAD-Commit überein). Aber Sie wissen, dass der bevorstehende Pull frotz.c oder filfre.c nicht beeinflusst, also setzen Sie die Indexänderungen für diese beiden Dateien zurück. Ihre Änderungen im Arbeitsbaum bleiben erhalten.

  4. Dann können Sie pullen und mergen, wobei die Änderungen in frotz.c und filfre.c weiterhin im Arbeitsbaum verbleiben.

Einen Commit rückgängig machen und neu erstellen
$ git commit ...
$ git reset --soft HEAD^      (1)
$ edit                        (2)
$ git commit -a -c ORIG_HEAD  (3)
  1. Dies geschieht meistens, wenn Sie sich erinnern, dass das, was Sie gerade committet haben, unvollständig ist, oder Sie haben Ihren Commit-Nachricht falsch geschrieben, oder beides. Lässt den Arbeitsbaum so, wie er vor dem "Reset" war.

  2. Nehmen Sie Korrekturen an den Arbeitsbaum-Dateien vor.

  3. "reset" kopiert den alten Kopf nach .git/ORIG_HEAD; erstellen Sie den Commit neu, indem Sie mit seiner Log-Nachricht beginnen. Wenn Sie die Nachricht nicht weiter bearbeiten müssen, können Sie stattdessen die Option -C verwenden.

    Siehe auch die Option --amend von git-commit[1].

Einen Commit rückgängig machen und ihn zu einem Topic-Branch machen
$ git branch topic/wip          (1)
$ git reset --hard HEAD~3       (2)
$ git switch topic/wip          (3)
  1. Sie haben einige Commits erstellt, erkennen aber, dass diese verfrüht für den master-Branch waren. Sie möchten sie in einem Topic-Branch weiter polieren, also erstellen Sie den Branch topic/wip ausgehend vom aktuellen HEAD.

  2. Spulen Sie den master-Branch zurück, um diese drei Commits zu entfernen.

  3. Wechseln Sie zum Branch topic/wip und arbeiten Sie weiter.

Commits dauerhaft rückgängig machen
$ git commit ...
$ git reset --hard HEAD~3   (1)
  1. Die letzten drei Commits (HEAD, HEAD^ und HEAD~2) waren schlecht und Sie möchten sie nie wieder sehen. Tun Sie dies **nicht**, wenn Sie diese Commits bereits jemand anderem gegeben haben. (Siehe den Abschnitt "RECOVERING FROM UPSTREAM REBASE" in git-rebase[1] für die Auswirkungen davon.)

Merge oder Pull rückgängig machen
$ git pull                         (1)
Auto-merging nitfol
CONFLICT (content): Merge conflict in nitfol
Automatic merge failed; fix conflicts and then commit the result.
$ git reset --hard                 (2)
$ git pull . topic/branch          (3)
Updating from 41223... to 13134...
Fast-forward
$ git reset --hard ORIG_HEAD       (4)
  1. Versuche, vom Upstream zu aktualisieren, führte zu vielen Konflikten; Sie waren im Moment nicht bereit, viel Zeit für das Mergen aufzuwenden, also beschlossen Sie, dies später zu tun.

  2. "pull" hat keinen Merge-Commit erstellt, also bereinigt git reset --hard, was ein Synonym für git reset --hard HEAD ist, das Durcheinander aus der Indexdatei und dem Arbeitsbaum.

  3. Führen Sie einen Topic-Branch in den aktuellen Branch zusammen, was zu einem Fast-Forward führte.

  4. Aber Sie haben beschlossen, dass der Topic-Branch noch nicht für die öffentliche Nutzung bereit ist. "pull" oder "merge" hinterlässt immer die ursprüngliche Spitze des aktuellen Branches in ORIG_HEAD, also bringt das harte Zurücksetzen darauf Ihre Indexdatei und den Arbeitsbaum in diesen Zustand zurück und setzt die Spitze des Branches auf diesen Commit zurück.

Merge oder Pull in einem schmutzigen Arbeitsbaum rückgängig machen
$ git pull                         (1)
Auto-merging nitfol
Merge made by recursive.
 nitfol                |   20 +++++----
 ...
$ git reset --merge ORIG_HEAD      (2)
  1. Selbst wenn Sie lokale Änderungen in Ihrem Arbeitsbaum haben, können Sie git pull sicher ausführen, wenn Sie wissen, dass die Änderung im anderen Branch sich nicht mit ihnen überschneidet.

  2. Nachdem Sie das Ergebnis des Merges geprüft haben, stellen Sie möglicherweise fest, dass die Änderung im anderen Branch unbefriedigend ist. Wenn Sie git reset --hard ORIG_HEAD ausführen, gelangen Sie zurück zu dem Zustand, in dem Sie waren, aber es werden Ihre lokalen Änderungen verworfen, was Sie nicht wollen. git reset --merge behält Ihre lokalen Änderungen.

Unterbrochener Workflow

Angenommen, Sie werden von einer dringenden Fehlerbehebungsanforderung unterbrochen, während Sie mitten in einer großen Änderung stecken. Die Dateien in Ihrem Arbeitsbaum sind noch nicht in einem Zustand, um committet zu werden, aber Sie müssen zu einem anderen Branch wechseln, um eine schnelle Fehlerbehebung durchzuführen.

$ git switch feature  ;# you were working in "feature" branch and
$ work work work      ;# got interrupted
$ git commit -a -m "snapshot WIP"                 (1)
$ git switch master
$ fix fix fix
$ git commit ;# commit with real log
$ git switch feature
$ git reset --soft HEAD^ ;# go back to WIP state  (2)
$ git reset                                       (3)
  1. Dieser Commit wird verworfen, daher ist eine Wegwerf-Log-Nachricht in Ordnung.

  2. Dies entfernt den *WIP*-Commit aus der Commit-Historie und versetzt Ihren Arbeitsbaum in den Zustand kurz vor der Erstellung dieses Snapshots.

  3. An diesem Punkt enthält die Indexdatei immer noch alle WIP-Änderungen, die Sie als *Snapshot WIP* committet haben. Dies aktualisiert den Index, um Ihre WIP-Dateien als uncommittet anzuzeigen.

    Siehe auch git-stash[1].

Eine einzelne Datei im Index zurücksetzen

Angenommen, Sie haben eine Datei zu Ihrem Index hinzugefügt, entscheiden sich aber später, sie nicht zu Ihrem Commit hinzuzufügen. Sie können die Datei aus dem Index entfernen, während Sie Ihre Änderungen mit git reset beibehalten.

$ git reset -- frotz.c                      (1)
$ git commit -m "Commit files in index"     (2)
$ git add frotz.c                           (3)
  1. Dies entfernt die Datei aus dem Index, während sie im Arbeitsverzeichnis verbleibt.

  2. Dies committet alle anderen Änderungen im Index.

  3. Fügt die Datei erneut zum Index hinzu.

Änderungen im Arbeitsbaum beibehalten, während einige vorherige Commits verworfen werden

Angenommen, Sie arbeiten an etwas und committen es, und dann arbeiten Sie etwas weiter, aber jetzt denken Sie, dass das, was Sie in Ihrem Arbeitsbaum haben, auf einem anderen Branch sein sollte, der nichts mit dem zu tun hat, was Sie zuvor committet haben. Sie können einen neuen Branch starten und ihn zurücksetzen, während Sie die Änderungen in Ihrem Arbeitsbaum beibehalten.

$ git tag start
$ git switch -c branch1
$ edit
$ git commit ...                            (1)
$ edit
$ git switch -c branch2                     (2)
$ git reset --keep start                    (3)
  1. Dies committet Ihre ersten Bearbeitungen im Branch branch1.

  2. Im Idealfall hätten Sie erkannt, dass der frühere Commit nicht zum neuen Thema gehörte, als Sie branch2 erstellt und zu ihm gewechselt haben (d. h. git switch -c branch2 start), aber niemand ist perfekt.

  3. Aber Sie können reset --keep verwenden, um den unerwünschten Commit zu entfernen, nachdem Sie zu branch2 gewechselt haben.

Einen Commit in eine Sequenz von Commits aufteilen

Angenommen, Sie haben viele logisch getrennte Änderungen erstellt und sie gemeinsam committet. Dann entscheiden Sie später, dass es besser wäre, wenn jeder logische Block mit seinem eigenen Commit verbunden wäre. Sie können git reset verwenden, um die Historie zurückzuspulen, ohne den Inhalt Ihrer lokalen Dateien zu ändern, und dann nacheinander git add -p verwenden, um interaktiv auszuwählen, welche Hunks in jeden Commit aufgenommen werden sollen, und git commit -c verwenden, um die Commit-Nachricht vorab auszufüllen.

$ git reset -N HEAD^                        (1)
$ git add -p                                (2)
$ git diff --cached                         (3)
$ git commit -c HEAD@{1}                    (4)
...                                         (5)
$ git add ...                               (6)
$ git diff --cached                         (7)
$ git commit ...                            (8)
  1. Zuerst setzen wir die Historie um einen Commit zurück, damit wir den ursprünglichen Commit entfernen, aber den Arbeitsbaum mit allen Änderungen belassen. Die Option -N stellt sicher, dass neue Dateien, die mit HEAD hinzugefügt wurden, weiterhin markiert sind, sodass git add -p sie findet.

  2. Als Nächstes wählen wir interaktiv Diff-Hunks zum Hinzufügen aus, indem wir die Funktionalität git add -p verwenden. Dies wird Sie nacheinander nach jedem Diff-Hunk fragen und Sie können einfache Befehle wie "Ja, diesen einschließen", "Nein, diesen nicht einschließen" oder sogar die sehr mächtige "Bearbeiten"-Funktion verwenden.

  3. Sobald Sie mit den Hunks, die Sie aufnehmen möchten, zufrieden sind, sollten Sie überprüfen, was für den ersten Commit vorbereitet wurde, indem Sie git diff --cached verwenden. Dies zeigt alle Änderungen an, die in den Index verschoben wurden und kurz vor dem Commit stehen.

  4. Als Nächstes committen Sie die im Index gespeicherten Änderungen. Die Option -c gibt an, dass die Commit-Nachricht aus der ursprünglichen Nachricht vorab ausgefüllt werden soll, mit der Sie im ersten Commit begonnen haben. Dies ist hilfreich, um erneutes Tippen zu vermeiden. HEAD@{1} ist eine spezielle Notation für den Commit, an dem HEAD vor dem ursprünglichen Reset-Commit (1 Änderung zuvor) war. Siehe git-reflog[1] für weitere Details. Sie können auch jede andere gültige Commit-Referenz verwenden.

  5. Sie können die Schritte 2-4 mehrmals wiederholen, um den ursprünglichen Code in eine beliebige Anzahl von Commits aufzuteilen.

  6. Nun haben Sie viele der Änderungen in eigene Commits aufgeteilt und verwenden möglicherweise nicht mehr den Patch-Modus von git add, um alle verbleibenden uncommitteten Änderungen auszuwählen.

  7. Überprüfen Sie noch einmal, ob Sie alles aufgenommen haben, was Sie wollten. Möglicherweise möchten Sie auch überprüfen, ob git diff keine verbleibenden Änderungen anzeigt, die später committet werden sollen.

  8. Und schließlich erstellen Sie den endgültigen Commit.

DISKUSSION

Die folgenden Tabellen zeigen, was passiert, wenn Sie

git reset --option target

ausführen, um HEAD auf einen anderen Commit (target) mit den verschiedenen Reset-Optionen zurückzusetzen, abhängig vom Zustand der Dateien.

In diesen Tabellen sind A, B, C und D verschiedene Zustände einer Datei. Zum Beispiel bedeutet die erste Zeile der ersten Tabelle, dass, wenn eine Datei im Arbeitsbaum im Zustand A, im Index im Zustand B, in HEAD im Zustand C und im Ziel im Zustand D ist, dann git reset --soft target die Datei im Arbeitsbaum im Zustand A und im Index im Zustand B belässt. Es setzt (d. h. bewegt) den HEAD (d. h. die Spitze des aktuellen Branches, wenn Sie sich auf einem befinden) auf target (das die Datei im Zustand D hat).

working index HEAD target         working index HEAD
----------------------------------------------------
 A       B     C    D     --soft   A       B     D
			  --mixed  A       D     D
			  --hard   D       D     D
			  --merge (disallowed)
			  --keep  (disallowed)
working index HEAD target         working index HEAD
----------------------------------------------------
 A       B     C    C     --soft   A       B     C
			  --mixed  A       C     C
			  --hard   C       C     C
			  --merge (disallowed)
			  --keep   A       C     C
working index HEAD target         working index HEAD
----------------------------------------------------
 B       B     C    D     --soft   B       B     D
			  --mixed  B       D     D
			  --hard   D       D     D
			  --merge  D       D     D
			  --keep  (disallowed)
working index HEAD target         working index HEAD
----------------------------------------------------
 B       B     C    C     --soft   B       B     C
			  --mixed  B       C     C
			  --hard   C       C     C
			  --merge  C       C     C
			  --keep   B       C     C
working index HEAD target         working index HEAD
----------------------------------------------------
 B       C     C    D     --soft   B       C     D
			  --mixed  B       D     D
			  --hard   D       D     D
			  --merge (disallowed)
			  --keep  (disallowed)
working index HEAD target         working index HEAD
----------------------------------------------------
 B       C     C    C     --soft   B       C     C
			  --mixed  B       C     C
			  --hard   C       C     C
			  --merge  B       C     C
			  --keep   B       C     C

git reset --merge ist für die Verwendung beim Zurücksetzen aus einem Merge-Konflikt vorgesehen. Jeder Merge-Vorgang garantiert, dass die Arbeitsbaumdatei, die am Merge beteiligt ist, keine lokalen Änderungen in Bezug auf den Index aufweist, bevor er beginnt, und dass das Ergebnis in den Arbeitsbaum geschrieben wird. Wenn wir also eine Differenz zwischen dem Index und dem Ziel sowie zwischen dem Index und dem Arbeitsbaum sehen, bedeutet dies, dass wir nicht aus einem Zustand zurücksetzen, in dem ein Merge-Vorgang nach einem fehlgeschlagenen Konflikt hinterlassen wurde. Deshalb ist die Option --merge in diesem Fall nicht zulässig.

git reset --keep ist für die Verwendung beim Entfernen einiger der letzten Commits im aktuellen Branch vorgesehen, während Änderungen im Arbeitsbaum beibehalten werden. Wenn es Konflikte zwischen den Änderungen im zu entfernenden Commit und den im Arbeitsbaum zu behaltenden Änderungen geben könnte, wird der Reset abgebrochen. Deshalb ist er nicht zulässig, wenn sowohl Änderungen zwischen dem Arbeitsbaum und HEAD als auch zwischen HEAD und dem Ziel vorhanden sind. Zur Sicherheit ist er auch nicht zulässig, wenn nicht zusammengeführte Einträge vorhanden sind.

Die folgenden Tabellen zeigen, was passiert, wenn nicht zusammengeführte Einträge vorhanden sind

working index HEAD target         working index HEAD
----------------------------------------------------
 X       U     A    B     --soft  (disallowed)
			  --mixed  X       B     B
			  --hard   B       B     B
			  --merge  B       B     B
			  --keep  (disallowed)
working index HEAD target         working index HEAD
----------------------------------------------------
 X       U     A    A     --soft  (disallowed)
			  --mixed  X       A     A
			  --hard   A       A     A
			  --merge  A       A     A
			  --keep  (disallowed)

X bedeutet beliebiger Zustand und U bedeutet einen nicht zusammengeführten Index.

GIT

Teil der git[1] Suite