Git Squash alle Commits

1. Git-Squashing
2. Verwenden Sie Git Interactive Rebase, um alle Commits zu komprimieren

Im Leben eines jeden Entwicklers fällt häufig das Wort squash bei der Arbeit mit dem verteilten Steuerungssystem Git. Diese Funktion in Git ist eine praktische Möglichkeit und wird von Entwicklern gerne für einen sauberen Arbeitsablauf in einem Entwicklerteam genutzt.

In diesem Block sprechen wir ausführlich über das Hauptmerkmal von Git, nämlich Squashing. Darüber hinaus der Prozess des Squashing und warum wir es brauchen, während wir mit dem Entwicklerteam arbeiten.

Git-Squashing

Zuerst müssen wir wissen, was Squashing ist. Im Allgemeinen mischt Squash etwas mit allen verfügbaren Dingen.

In Git wird der Begriff squash verwendet, um verschiedene Commits über die Kommandozeile zu einem Commit zusammenzufassen. Und diese Funktion hält das Ding in der richtigen Reihenfolge wie zuerst rein, zuerst raus.

Lassen Sie uns die Squashing- und Sequencing-Reihenfolge in Commits mit einem Beispiel unten erklären.

     A ◄───── B ◄──── C ◄───── D


 After Squashing commits B, C, and D:

     A ◄───── E


  Commit E includes the commits B, C, and D changes.

Nehmen wir an, wir führen alle Commits zu einem neuen commit E zusammen. Jetzt umfasst commit E Änderungen, die in Commits B, C und D vorgenommen wurden.

Das Squashing wird speziell durchgeführt, um den Zweiggraphen in einem längeren Lebenszyklus sauber zu halten.

Wenn wir mit einer neuen Funktion in einer Anwendung arbeiten, ist es offensichtlich, dass wir ein paar Commits vornehmen, bevor wir das gewünschte Ergebnis erzielen. Das können einige Korrekturen der vom Qualitätssicherungsteam gemeldeten Fehler oder einige Tests sein.

Nachdem wir diese Funktionen angewendet haben, haben wir einige unwesentliche Commits gesammelt, die unseren Zweig mit Commits unordentlich aussehen lassen. Für dieses Szenario verwenden wir Squashing in diesem Repository-Zweig.

Es wird uns helfen, diese redundanten Commits zu einem zu kombinieren.

Der wichtigste Punkt, an den hier erinnert werden muss, ist, dass squash kein Git-Befehl ist. Es ist jedoch eine wesentliche Git-Operation.

Wenn wir git squash ausführen, erhalten wir einen Fehler, da es nur eine Operation ist und über den Git-Befehl interactive rebase ausgeführt werden kann.

Verwenden Sie Git Interactive Rebase, um alle Commits zu komprimieren

Mit der interaktiven Rebase-Funktion von Git können wir unsere Commits jederzeit und zu jedem Zeitpunkt des Zweiglebenszyklus manuell squashen. Beginnen wir mit der Ausführung des folgenden Befehls mit dem Alias slog, der uns hilft, das kompakte Commit-Protokoll anzuzeigen.

git config --global alias.slog = log --graph --all --topo-order --pretty='format:%h %ai %s%d (%an)'

Ausgang:

$ git slog
* ac1sd5f 2022-02-11 11:09:15 +0600 Commit D (HEAD -> master) (test)
* 5dasq6f 2022-02-11 11:09:02 +0600 Commit C (test)
* 5asa04d 2022-02-11 11:09:02 +0600 Commit B (test)
* c40as62 2022-02-11 11:10:56 +0600 Commit A (test)
* 29awqc5 2022-02-11 11:10:33 +0600 BugFix #1 (test)
* 3asafeb 2022-02-11 11:10:19 +v Feature1 implemented (test)
* cbas10d 2022-02-11 11:26:19 +0600 Init commit (test)

Auch hier zeigt der Git-Befehl Interactive Rebase alle relevanten Commits im Standard-Editor mit der Reihenfolge der Sequenzierung an. Hier wollen wir diese Commits squashen, kontrollieren und mit dem Git-Befehl im Editor speichern.

Es folgt der Befehl, der verwendet wird, um die letzten X-Commits zu komprimieren:

git rebase -i HEAD~[X]Copy

Da wir die letzten 4 Commits squashen wollen, nennen wir ab dem obigen Befehl 4 statt X.

git rebase -i HEAD~4Copy

Wenn wir von letzten X Commits sprechen, meinen wir die letzten x Commits vom Kopf bis zum Ende.

Als Ergebnis des interaktiven Rebase wird der Standardeditor von Git gestartet und beginnt, die Commits, die wir in einem Commit haben wollten, zu komprimieren. Die mit dem Befehl pick aufgelisteten Commits sind diejenigen, die wir squashen wollen.

Jetzt werden wir die Befehlsauswahl von Commits in s oder squash ändern, damit diese Commits gesquash werden.

Danach speichern wir unsere Änderungen und schließen den Editor. Die Operation git rebase wird gemäß unseren Anweisungen durchgeführt.

$ git rebase -i HEAD~4
[detached HEAD fa29cd5] Commit A
 Date: Tue Sep 04 11:10:11 2022 +0600
 1 file changed, 1 insertion(+), 1 deletion(-)
Successfully rebased and updated refs/heads/master.

Rebase wurde erfolgreich durchgeführt. Zu unserer Zufriedenheit können wir uns unser Commit-Log ansehen, indem wir noch einmal den Befehl git slog wie folgt ausführen:

$ git slog
* f9SAEd5 2022-05-22 4:09:02  +0600 Commit A (HEAD -> master) (test)
* 29aS6c5 2022-05-22 4:09:02  +0600 BugFix #1 (test)
* 34faseb 2022-05-22 4:09:02  +0600 Feature1 implemented (test)
* cbadw0d 2022-05-22 4:09:02  +0600 Init commit (test)

Wie wir im obigen Ausgabefenster sehen können, wurden schließlich die letzten 4 Commits zu einem zusammengefasst, und es war für Entwickler einfach, alle vier verschiedenen Commits dazu zu bringen, in einem einzigen Feature-Commit zu arbeiten.