Git Reset und Revert Tutorial für Einsteiger

Git Revert vs. Reset 

Diese beiden Befehle werden in Git verwendet, um Änderungen am Projektcode und an der Historie rückgängig zu machen, allerdings auf unterschiedliche Weise. In diesem Abschnitt bekommst du einen Überblick darüber, wie du sie nutzen kannst. Bevor wir in den Prozess eintauchen, erstellen wir zunächst ein Git-Projekt.

Ein Git-Projekt erstellen

Im Folgenden findest du die Anweisungen, um ein Git-Projekt zu erstellen und es mit einigen Dateien zu initialisieren:

mkdir git_revert_reset
cd git_revert_reset
git init .

• mkdir git_revert_reset erstellt einen Ordner namens git_revert_reset. 
• cd git_revert_reset bewegt sich in den Ordner. 
• git init . initialisiert den Ordner als Git-Repository.

Da es sich um ein Data Science-Projekt handelt, können wir mit diesem touch Befehl die folgenden Dateien für die Datenerfassung, die Datenvorverarbeitung und das Modelltraining erstellen:

touch data_acquisition.py data_preprocessing.py model_training.py

Dies ist der endgültige Inhalt des Projektordners.

git_revert_reset
      |---------- data_acquisition.py
      |---------- data_preprocessing.py
      |---------- model_training.py

Git Reset 

Git Reset Diagramm(Quelle)

Der Befehl git reset wird verwendet, um die Änderungen in deinem Arbeitsverzeichnis rückgängig zu machen und zu einem bestimmten Commit zurückzukehren, während alle Commits, die nach diesem Commit gemacht wurden, verworfen werden. 

Stell dir zum Beispiel vor, du hast zehn Commits gemacht. Wenn du den ersten Commit mit git reset zurücksetzt, werden alle neun Commits gelöscht und du kehrst zur ersten Commit-Phase zurück.

Bevor du git reset verwendest, ist es wichtig, dass du dir überlegst, welche Art von Veränderungen du vorhast, denn sonst richtest du mehr Chaos an als Gutes. 

Du kannst mehrere Optionen zusammen mit git reset verwenden, aber dies sind die wichtigsten. Jede wird je nach Situation verwendet: git reset --soft, git reset --mixed, und git reset --hard

git reset --soft

Die Option --soft zielt darauf ab, die HEAD-Referenz (wo sich der letzte Commit auf deinem lokalen Rechner befindet) auf einen bestimmten Commit zu ändern. Wenn wir z.B. feststellen, dass wir vergessen haben, eine Datei zum Commit hinzuzufügen, können wir das mit der Option --soft im folgenden Format nachholen:

• git reset --soft HEAD~n um zum Commit mit einer bestimmten Referenz (n) zurückzugehen. git reset --soft HEAD~1 geht zurück zum letzten Commit.
• git reset --soft bewegt sich zurück zum Kopf mit dem

Schauen wir uns einige Beispiele an.

git add data_acquisition.py data_preprocessing.py

git add data

git commit -m "added data acquisition and preprocessing scripts"

Dies ist das Ergebnis des vorherigen Befehls. 

[master (root-commit) faf864e] added python scripts and data folder
2 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 data_acquisition.py
create mode 100644 data_preprocessing.py

Wir können den Status der Übergabe wie folgt überprüfen:

git status

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

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

Aber wir haben vergessen, das Skript model_training.py zum Commit hinzuzufügen.

Da sich der letzte Commit im HEAD befindet, können wir dieses Problem beheben, indem wir die folgenden drei Anweisungen ausführen. 

• Gehe zurück in die Pre-Commit-Phase, indem du git reset --soft HEAD die Datei git reset erlaubst.
• Füge die vergessene Datei mit git add 
• Nimm die Änderungen mit einer endgültigen Übergabe git commit vor.

git reset --soft HEAD

git add model_training.py

git commit -m "added all the python scripts"

Das folgende Ergebnis hat git nach allen vorherigen Schritten auf master zurückgesetzt: 

[master (root-commit) faf864e] added all the python scripts
3 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 data_acquisition.py
create mode 100644 data_preprocessing.py
create mode 100644 model_training.py

git reset --mixed

Dies ist das Standardargument für git reset. Die Ausführung dieses Befehls hat zwei Auswirkungen: (1) Hebe alle Änderungen auf und (2) hebe sie wieder auf. 

Stell dir vor, wir haben versehentlich die Datei model_training.py hinzugefügt und wollen sie wieder entfernen, weil das Modelltraining noch nicht abgeschlossen ist. 

So gehst du vor: 

• Hebe die Dateien, die in der Übergabe waren, mit git reset HEAD wieder auf
• Füge nur die Dateien hinzu, die wir für die Übertragung benötigen

git reset HEAD

git status

On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
model_training.py
data_acquisition.py
data_preprocessing.py

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

Jetzt können wir nur noch die letzten beiden Dateien hinzufügen und den Commit durchführen.

git add data_acquisition.py data_preprocessing.py

git commit -m "Removed the model_training.py from the commit"

git reset --hard

Diese Option birgt das Potenzial, gefährlich zu sein. Sei also vorsichtig, wenn du es benutzt! 

Wenn du den Hard Reset für einen bestimmten Commit verwendest, zwingt er den HEAD, zu diesem Commit zurückzukehren und löscht alles andere danach.

Bevor du den Hard-Reset durchführst, lass uns einen Blick auf den Inhalt des Ordners werfen.

ls
data_acquisition.py data_preprocessing.py model_training.py

git reset --hard
HEAD is now at 97159bc added data acquisition and preprocessing scripts

Jetzt lass uns den Inhalt des Ordners überprüfen:

ls
data_acquisition.py data_preprocessing.py

Wir stellen fest, dass die nicht verfolgte Datei model_training.py gelöscht wird. Auch hier gilt: Mach dir klar, was du mit der Reset-Anweisung machst, denn die Folgen können dramatisch sein!

Git Revert

Vor und nach der Umkehrung(Quelle)

Git revert ist ähnlich wie git reset, aber der Ansatz ist etwas anders. Anstatt alle Commits zu löschen, die ihm im Weg stehen, macht der Revert NUR einen einzelnen Commit rückgängig, indem er dich zu den Stagedateien vor dem Commit zurückbringt.

Anstatt einen Commit zu löschen, kehrt git revert die Änderungen des ursprünglichen Commits um und erstellt einen neuen Commit mit dem umgekehrten Inhalt. Das ist ein sicherer Weg, um einen Commit zu widerrufen, weil du so deinen Verlauf nicht verlierst. 

Es ist wichtig zu wissen, dass der Revert keine Auswirkungen hat, wenn der Commit-Hash oder die Referenz nicht angegeben wird. 

Sehen wir uns ein paar gängige Optionen für Git Revert an.

git revert --no-edit <commit ID>

Mit der Option --no-edit kannst du die Nachricht für den Commit, den du rückgängig machen willst, nicht ändern, so dass Git die Datei in den Master-Branch zurückstellt.

Um dieses Szenario zu veranschaulichen, erstellen wir zwei neue Dateien, die hinzugefügt werden sollen. 

touch model_monitoring.py data_monitoring.py

Nachdem wir diese Dateien erstellt haben, müssen wir sie dem Staging-Bereich für die geänderte Version hinzufügen.

git add model_monitoring.py

Bevor wir weitermachen, lass uns einen Blick auf den Status werfen, indem wir den folgenden Befehl ausführen.

git status
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file:   data_monitoring.py
new file:   model_monitoring.py

Wir sehen, dass die beiden Dateien hinzugefügt wurden und können nun die Änderungen übertragen.

git commit -m "Added the monitoring script files"
[master (root-commit) eae84e7] Added the monitoring script files
2 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 data_monitoring.py
create mode 100644 model_monitoring.py

Dann kann der Commit-Hash mit dem folgenden Befehl erzeugt werden. Das ist von Vorteil, wenn du versuchst, eine Aktion für diesen bestimmten Commit durchzuführen. 

git reflog
eae84e7 (HEAD -> master) HEAD@{0}: commit (initial): Added the monitoring script files

Nehmen wir nun an, dass der vorherige Commit nicht beabsichtigt war und wir ihn loswerden wollen.

git revert --no-edit eae84e7

[master c61ef6b] Revert "Added the monitoring script files"
Date: Sat Nov 12 20:14:17 2022 -0600
2 files changed, 0 insertions(+), 0 deletions(-)
delete mode 100644 data_monitoring.py
delete mode 100644 model_monitoring.py

Werfen wir einen Blick auf das Log der Commits:

git log

commit c61ef6b4e86f41f47c8c77de3b5fca3945a7c075 (HEAD -> master)
Author: Zoumana Keita <keitnekozou@gmail.com>
Date:   Sat Nov 12 20:14:17 2022 -0600

  Revert "Added the monitoring script files"
 
  This reverts commit eae84e7669af733ee6c1b854f2fcd9acfea9d4a3.

commit eae84e7669af733ee6c1b854f2fcd9acfea9d4a3
Author: Zoumana Keita <keitnekozou@gmail.com>
Date:   Sat Nov 12 20:05:57 2022 -0600

  Added the monitoring script files

Im Log können wir sehen, dass ein neuer Commit mit der ID c61ef6b4e86f41f47c8c77de3b5fca3945a7c075 erstellt wurde, um den ursprünglichen Commit mit der ID eae84e7669af733ee6c1b854f2fcd9acfea9d4a3 rückgängig zu machen. 

Da wir in diesem Beispiel nur einen einzigen Commit haben, könnten wir einfach git revert HEAD, verwenden, was den gleichen Effekt hätte, indem es den letzten Commit rückgängig macht.

git revert <commit hash>

Dadurch werden nur die Änderungen entfernt, die mit diesem Commit-Hash verbunden sind, und keine anderen Commits beeinflusst.

Welcher Git Revert wird deiner Meinung nach einen Effekt haben, wenn man die zuvor erstellte ID berücksichtigt? 

Wenn deine Antwort c61ef6b4e86f41f47c8c77de3b5fca3945a7c075 war, hast du Recht. Die Berücksichtigung von eae84e7669af733ee6c1b854f2fcd9acfea9d4a3 hat keine Auswirkungen, da sie durch eine neue ersetzt wird. 

Mal sehen, was dann passiert, wenn du versuchst, den Revert durchzuführen.

git revert c61ef6b4e86f41f47c8c77de3b5fca3945a7c075

[master aaead40] Revert "Revert "Added the monitoring script files""

 2 files changed, 0 insertions(+), 0 deletions(-)

 create mode 100644 data_monitoring.py

 create mode 100644 model_monitoring.py

Wie du sehen kannst, wurden die beiden Dateien, die ursprünglich erstellt und übertragen wurden, wiederhergestellt!

git revert --no-commit <Commit ID>

Der Zweck der Optionen --no-commit oder -n ist es, zu verhindern, dass Git den Revert automatisch committiert. Dies kann von Vorteil sein, wenn du die durch die revert-Anweisung vorgenommenen Änderungen überprüfen willst, bevor du sie festschreibst.

Betrachten wir das folgende Beispiel: 

git revert --no-commit c61ef6b4e86f41f47c8c77de3b5fca3945a7c075

Dadurch werden die Änderungen des Commits mit der ID c61ef6b4e86f41f47c8c77de3b5fca3945a7c075 rückgängig gemacht, aber es wird nicht automatisch ein neuer Commit erstellt, um die Rückgängigmachung aufzuzeichnen. Stattdessen werden die Änderungen unbearbeitet belassen, damit du sie überprüfen und entscheiden kannst, ob du die Rückgängigmachung manuell vornehmen willst.

Wann sollte man Git Revert vs. Reset verwenden?

Git Revert 

• Mit git revert kannst du zu einem früheren Zustand zurückkehren, während du einen neuen Commit erstellst.
• Entscheide dich für diese Option, wenn du zur Sicherheit Änderungen an einem öffentlichen Zweig rückgängig machen willst.

Git Reset

• Mit git reset kannst du zu den vorherigen Commits zurückgehen, aber keinen neuen Commit erstellen. 
• Diese Option ist besser, wenn du Änderungen in einem privaten Zweig rückgängig machen willst.

Fazit

In diesem Tutorial haben wir gesehen, wie man einen Git-Reset durchführt und Änderungen in deinem Git-Repository rückgängig macht. Denke daran, dass ein Hard-Reset sehr gefährlich sein kann, weil dabei deine nicht verfolgten Dateien im Projekt verloren gehen. 

Was kommt also als Nächstes? 

In unserem Blog gibt es mehrere Tutorials, die ein guter nächster Schritt sein können, um deine Git-Kenntnisse zu verbessern, wie z.B:

• Auflösen von Merge-Konflikten in Git Tutorial
• GitHub und Git Tutorial für Einsteiger
• Git Push und Pull Tutorial