Wie kann ich meine letzten X-Commits mit Git zu einem Commit zusammenfassen?

Verwenden git rebase -i <after-this-commit>und ersetzen Sie "pick" beim zweiten und nachfolgenden Commit durch "squash" oder "fixup", wie im Handbuch beschrieben .

In diesem Beispiel <after-this-commit>ist dies entweder der SHA1-Hash oder die relative Position vom HEAD des aktuellen Zweigs, von dem aus Commits für den Rebase-Befehl analysiert werden. Wenn der Benutzer beispielsweise 5 Commits vom aktuellen HEAD in der Vergangenheit anzeigen möchte, lautet der Befehl git rebase -i HEAD~5.

Sie können dies ziemlich einfach ohne git rebaseoder tun git merge --squash. In diesem Beispiel werden die letzten 3 Commits gequetscht.

Wenn Sie die neue Festschreibungsnachricht von Grund auf neu schreiben möchten, reicht dies aus:

git reset --soft HEAD~3 &&
git commit

Wenn Sie mit dem Bearbeiten der neuen Festschreibungsnachricht mit einer Verkettung der vorhandenen Festschreibungsnachrichten beginnen möchten (dh ähnlich wie mit einer Befehlsliste pick / squash / squash /… / squash git rebase -i), müssen Sie diese Nachrichten extrahieren und übergeben sie zu git commit:

git reset --soft HEAD~3 && 
git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"

Beide Methoden zerlegen die letzten drei Commits auf dieselbe Weise zu einem einzigen neuen Commit. Der Soft-Reset zeigt HEAD nur auf das letzte Commit, das Sie nicht quetschen möchten. Weder der Index noch der Arbeitsbaum werden vom Soft-Reset berührt, sodass der Index für Ihr neues Commit im gewünschten Zustand bleibt (dh er enthält bereits alle Änderungen gegenüber den Commits, die Sie "wegwerfen" möchten).

Sie können dafür verwenden git merge --squash, was etwas eleganter ist als git rebase -i. Angenommen, Sie sind auf dem Master und möchten die letzten 12 Commits zu einem zusammenfassen.

WARNUNG: Stellen Sie zunächst sicher, dass Sie Ihre Arbeit festschreiben - überprüfen Sie, ob diese git statussauber ist (da git reset --hardinszenierte und nicht inszenierte Änderungen weggeworfen werden).

Dann:

# Reset the current branch to the commit just before the last 12:
git reset --hard HEAD~12

# HEAD@{1} is where the branch was just before the previous command.
# This command sets the state of the index to be as it would just
# after a merge from that commit:
git merge --squash HEAD@{1}

# Commit those squashed changes.  The commit message will be helpfully
# prepopulated with the commit messages of all the squashed commits:
git commit

In der Dokumentation zugit merge wird die --squashOption ausführlicher beschrieben.

Update: Der einzige wirkliche Vorteil dieser Methode gegenüber dem git reset --soft HEAD~12 && git commitvon Chris Johnsen in seiner Antwort vorgeschlagenen einfacheren ist, dass Sie die Festschreibungsnachricht mit jeder Festschreibungsnachricht, die Sie quetschen, vorab ausgefüllt erhalten.

Ich empfehle, git resetwenn möglich zu vermeiden - besonders für Git-Neulinge. Wenn Sie einen Prozess, der auf einer Reihe von Commits basiert, nicht wirklich automatisieren müssen , gibt es einen weniger exotischen Weg ...

1. Legen Sie die zu quetschenden Commits auf einen funktionierenden Zweig (falls noch nicht geschehen) - verwenden Sie dazu gitk
2. Überprüfen Sie den Zielzweig (z. B. 'Master').
3. git merge --squash (working branch name)
4. git commit

Die Festschreibungsnachricht wird basierend auf dem Squash vorab ausgefüllt.

Basierend auf der Antwort von Chris Johnsen ,

Fügen Sie einen globalen "Squash" -Alias ​​von bash hinzu: (oder Git Bash unter Windows)

git config --global alias.squash '!f(){ git reset --soft HEAD~${1} && git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"; };f'

... oder über die Windows-Eingabeaufforderung:

git config --global alias.squash "!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f"

Sie ~/.gitconfigsollten jetzt diesen Alias ​​enthalten:

[alias]
    squash = "!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f"

Verwendungszweck:

git squash N

... die automatisch die letzten NCommits zusammenquetscht, einschließlich.

Hinweis: Die resultierende Festschreibungsnachricht ist eine Kombination aller gequetschten Festschreibungen in der angegebenen Reihenfolge. Wenn Sie damit nicht zufrieden sind, können Sie es jederzeit git commit --amendmanuell ändern. (Oder bearbeiten Sie den Alias ​​nach Ihrem Geschmack.)

Dank dieses praktischen Blogposts habe ich festgestellt, dass Sie diesen Befehl verwenden können, um die letzten 3 Commits zu quetschen:

git rebase -i HEAD~3

Dies ist praktisch, da es auch dann funktioniert, wenn Sie sich in einer lokalen Filiale ohne Tracking-Informationen / Remote-Repo befinden.

Der Befehl öffnet den interaktiven Rebase-Editor, mit dem Sie wie gewohnt neu ordnen, quetschen, umformulieren usw. können.

Verwenden des interaktiven Rebase-Editors:

Der interaktive Rebase-Editor zeigt die letzten drei Commits an. Diese Einschränkung wurde durch HEAD~3Ausführen des Befehls bestimmt git rebase -i HEAD~3.

Das letzte Commit HEADwird zuerst in Zeile 1 angezeigt. Die mit a beginnenden Zeilen #sind Kommentare / Dokumentationen.

Die angezeigte Dokumentation ist ziemlich klar. In jeder Zeile können Sie den Befehl von pickin einen Befehl Ihrer Wahl ändern .

Ich bevorzuge die Verwendung des Befehls, fixupda dies die Änderungen des Commits in das Commit in der obigen Zeile "quetscht" und die Nachricht des Commits verwirft.

Da das Commit in Zeile 1 lautet HEAD, würden Sie dies in den meisten Fällen als belassen pick. Sie können nicht verwenden squashoder fixupda es kein anderes Commit gibt, in das Sie das Commit drücken können.

Sie können auch die Reihenfolge der Commits ändern. Auf diese Weise können Sie Commits quetschen oder korrigieren, die chronologisch nicht benachbart sind.

Ein praktisches Alltagsbeispiel

Ich habe kürzlich eine neue Funktion festgelegt. Seitdem habe ich zwei Bugfixes begangen. Aber jetzt habe ich einen Fehler (oder vielleicht nur einen Rechtschreibfehler) in der neuen Funktion entdeckt, die ich begangen habe. Wie nervig! Ich möchte kein neues Commit, das meine Commit-Historie verschmutzt!

Als erstes behebe ich den Fehler und mache ein neues Commit mit dem Kommentar squash this into my new feature!.

Ich starte dann git logoder gitkund erhalte die Commit-SHA der neuen Funktion (in diesem Fall 1ff9460).

Als nächstes rufe ich den interaktiven Rebase-Editor mit auf git rebase -i 1ff9460~. Die ~SHA nach dem Festschreiben weist den Editor an, dieses Festschreiben in den Editor aufzunehmen.

Als Nächstes verschiebe ich das Commit mit dem fix ( fe7f1e0) unter das Feature-Commit und wechsle pickzu fixup.

Wenn Sie den Editor schließen, wird das Update in das Feature-Commit gequetscht und mein Commit-Verlauf sieht gut und sauber aus!

Dies funktioniert gut, wenn alle Commits lokal sind. Wenn Sie jedoch versuchen, bereits auf die Fernbedienung übertragene Commits zu ändern, können Sie anderen Entwicklern, die denselben Zweig ausgecheckt haben, wirklich Probleme bereiten!

Wenn Sie TortoiseGit verwenden, können Sie die Funktion Combine to one commit:

1. Öffnen Sie das TortoiseGit-Kontextmenü
2. Wählen Show Log
3. Markieren Sie die entsprechenden Commits in der Protokollansicht
4. Wählen Sie Combine to one commitaus dem Kontextmenü

Diese Funktion führt automatisch alle erforderlichen Single-Git-Schritte aus. Leider nur für Windows verfügbar.

Dazu können Sie den folgenden git-Befehl verwenden.

 git rebase -i HEAD~n

n (= 4 hier) ist die Anzahl der letzten Festschreibungen. Dann haben Sie folgende Optionen:

pick 01d1124 Message....
pick 6340aaa Message....
pick ebfd367 Message....
pick 30e0ccb Message....

Aktualisieren Sie wie unten beschrieben pickein Commit und squashdie anderen in das neueste,

p 01d1124 Message....
s 6340aaa Message....
s ebfd367 Message....
s 30e0ccb Message....

Für Details klicken Sie auf den Link

Basierend auf diesem Artikel fand ich diese Methode für meinen Anwendungsfall einfacher.

Mein 'dev'-Zweig lag um 96 Commits vor' origin / dev '(daher wurden diese Commits noch nicht auf die Fernbedienung übertragen).

Ich wollte diese Commits zu einem zusammenfassen, bevor ich die Änderung vorantreibe. Ich ziehe es vor, den Zweig auf den Status 'origin / dev' zurückzusetzen (dies lässt alle Änderungen von den 96 Commits nicht inszeniert) und dann die Änderungen sofort festzuschreiben:

git reset origin/dev
git add --all
git commit -m 'my commit message'

Führen Sie in der Verzweigung, in der Sie die Commits kombinieren möchten, Folgendes aus:

git rebase -i HEAD~(n number of commits back to review)

Beispiel:

git rebase -i HEAD~1

Dadurch wird der Texteditor geöffnet und Sie müssen die Auswahl vor jedem Commit durch "Squash" ersetzen, wenn diese Commits zusammengeführt werden sollen. Aus der Dokumentation:

p, pick = use commit

s, squash = Commit verwenden, aber mit dem vorherigen Commit verschmelzen

Wenn Sie beispielsweise alle Commits zu einem zusammenführen möchten, ist die Auswahl das erste Commit, das Sie vorgenommen haben, und alle zukünftigen Commits (unter dem ersten) sollten auf "Squash" gesetzt werden. Wenn Sie vim verwenden, verwenden Sie : x im Einfügemodus, um den Editor zu speichern und zu beenden.

Dann, um die Rebase fortzusetzen:

git rebase --continue

Weitere Informationen zu diesem und anderen Möglichkeiten zum Umschreiben Ihres Commit-Verlaufs finden Sie in diesem hilfreichen Beitrag

Die Antwort von Anomies ist gut, aber ich fühlte mich unsicher, deshalb habe ich beschlossen, ein paar Screenshots hinzuzufügen.

Schritt 0: Git-Protokoll

Sehen Sie, wo Sie sind git log. Am wichtigsten ist, dass Sie den Commit-Hash des ersten Commits finden, den Sie nicht quetschen möchten. Also nur die:

Schritt 1: Git Rebase

Führen Sie git rebase -i [your hash]in meinem Fall aus:

$ git rebase -i 2d23ea524936e612fae1ac63c95b705db44d937d

Schritt 2: Wählen / quetschen Sie, was Sie wollen

In meinem Fall möchte ich alles auf dem Commit zerquetschen, was zum ersten Mal war. Die Bestellung erfolgt vom ersten bis zum letzten, also genau umgekehrt wie in git log. In meinem Fall möchte ich:

Schritt 3: Nachricht (en) anpassen

Wenn Sie nur ein Commit ausgewählt und den Rest gequetscht haben, können Sie eine Commit-Nachricht anpassen:

Das ist es. Sobald Sie dies ( :wq) gespeichert haben, sind Sie fertig. Schau es dir an mit git log.

Vorgehensweise 1

1) Identifizieren Sie den Commit Short Hash

# git log --pretty=oneline --abbrev-commit
abcd1234 Update to Fix for issue B
cdababcd Fix issue B
deab3412 Fix issue A
....

Hier kann sogar git log --onelineauch verwendet werden, um kurzen Hash zu bekommen.

2) Wenn Sie die letzten beiden Commits quetschen (zusammenführen) möchten

# git rebase -i deab3412 

3) Dies öffnet einen nanoEditor zum Zusammenführen. Und es sieht aus wie unten

....
pick cdababcd Fix issue B
pick abcd1234 Update to Fix for issue B
....

4) Benennen Sie das vorher vorhandene Wort pickum . Nach dem Umbenennen sollte es wie folgt sein.squashabcd1234

....
pick cdababcd Fix issue B
squash abcd1234 Update to Fix for issue B
....

5) Speichern und schließen Sie nun den nanoEditor. Drücken Sie ctrl + ound drücken Sie Enterzu speichern. Drücken Sie dann ctrl + x, um den Editor zu verlassen.

6) Anschließend wird der nanoEditor erneut geöffnet, um Kommentare zu aktualisieren und gegebenenfalls zu aktualisieren.

7) Jetzt ist es erfolgreich gequetscht. Sie können es überprüfen, indem Sie die Protokolle überprüfen.

# git log --pretty=oneline --abbrev-commit
1122abcd Fix issue B
deab3412 Fix issue A
....

8) Drücken Sie nun auf Repo. Hinweis zum Hinzufügen eines +Zeichens vor dem Filialnamen. Dies bedeutet erzwungenen Druck.

# git push origin +master

Hinweis: Dies basiert auf der Verwendung von git on ubuntushell. Wenn Sie ein anderes Betriebssystem ( Windowsoder Mac) verwenden, sind die obigen Befehle mit Ausnahme des Editors identisch. Möglicherweise erhalten Sie einen anderen Editor.

Vorgehensweise 2

1. Fügen Sie zuerst die erforderlichen Dateien für das Festschreiben hinzu

git add <files>

2. Dann Commit mit --fixupOption und das OLDCOMMITsollte sein, auf dem wir dieses Commit zusammenführen (Squash) müssen.

git commit --fixup=OLDCOMMIT

Dies schafft nun ein neues Commit über HEAD mit fixup1 <OLDCOMMIT_MSG>.

3. Führen Sie dann den folgenden Befehl aus, um das neue Commit mit dem zusammenzuführen (zu quetschen) OLDCOMMIT.

git rebase --interactive --autosquash OLDCOMMIT^

Hier ^bedeutet das vorherige Commit zu OLDCOMMIT. Dieser rebaseBefehl öffnet ein interaktives Fenster in einem Editor (vim oder nano), in dem Sie nichts weiter tun müssen, nur das Speichern und Beenden ist ausreichend. Da die an diese Option übergebene Option das letzte Commit automatisch neben das alte Commit verschiebt und den Vorgang in fixup(entspricht Squash) ändert . Dann wird die Rebase fortgesetzt und beendet.

Vorgehensweise 3

1. Wenn neue Änderungen am letzten Commit hinzugefügt werden müssen, --amendkönnen Mittel mit verwendet werden git-commit.

    # git log --pretty=oneline --abbrev-commit
    cdababcd Fix issue B
    deab3412 Fix issue A
    ....
    # git add <files> # New changes
    # git commit --amend
    # git log --pretty=oneline --abbrev-commit
    1d4ab2e1 Fix issue B
    deab3412 Fix issue A
    ....  

Hier werden --amenddie neuen Änderungen zum letzten Commit zusammengeführt cdababcdund eine neue Commit-ID generiert1d4ab2e1

Fazit

• Der Vorteil des ersten Verfahrens besteht darin, mehrere Commits zu quetschen und neu zu ordnen. Dieses Verfahren wird jedoch schwierig, wenn wir einen Fix für ein sehr altes Commit zusammenführen müssen.
• Das zweite Verfahren hilft also dabei, das Commit leicht mit einem sehr alten Commit zusammenzuführen.
• Das dritte Verfahren ist in einem Fall hilfreich, um neue Änderungen für das letzte Festschreiben zu unterdrücken.

So zerquetschen Sie die letzten 10 Commits zu einem einzigen Commit:

git reset --soft HEAD~10 && git commit -m "squashed commit"

Wenn Sie auch den Remote-Zweig mit dem Squashed Commit aktualisieren möchten:

git push -f

Wenn Sie sich in einem Remote-Zweig (aufgerufen feature-branch) befinden, der aus einem Golden Repository () geklont wurde golden_repo_name, können Sie Ihre Commits wie folgt in einen Zweig zerlegen :

1. Kasse das goldene Repo

   git checkout golden_repo_name
   

2. Erstellen Sie daraus einen neuen Zweig (goldenes Repo) wie folgt

   git checkout -b dev-branch
   

3. Squash wird mit Ihrer lokalen Niederlassung zusammengeführt, die Sie bereits haben

   git merge --squash feature-branch
   

4. Übernehmen Sie Ihre Änderungen (dies ist das einzige Commit, das in dev-branch ausgeführt wird).

   git commit -m "My feature complete"
   

5. Schieben Sie den Zweig in Ihr lokales Repository

   git push origin dev-branch
   

Was wirklich praktisch sein kann:
Finden Sie beispielsweise den Commit-Hash, auf den Sie Squash ausführen möchtend43e15 .

Jetzt benutzen

git reset d43e15
git commit -am 'new commit name'

Das ist super-duper kludgy, aber irgendwie cool, also werfe ich es einfach in den Ring:

GIT_EDITOR='f() { if [ "$(basename $1)" = "git-rebase-todo" ]; then sed -i "2,\$s/pick/squash/" $1; else vim $1; fi }; f' git rebase -i foo~5 foo

Übersetzung: Stellen Sie einen neuen "Editor" für git bereit, der, wenn der zu bearbeitende Dateiname lautet git-rebase-todo (die interaktive Rebase-Eingabeaufforderung), alle bis auf die erste "Auswahl" in "Squash" ändert und ansonsten vim erzeugt - so dass, wenn Sie dazu aufgefordert werden Um die Squashed Commit-Nachricht zu bearbeiten, erhalten Sie vim. (Und natürlich habe ich die letzten fünf Commits auf Branch Foo gequetscht, aber Sie können das ändern, wie Sie möchten.)

Ich würde wahrscheinlich tun, was Mark Longair vorgeschlagen hat.

Wenn Sie jedes Commit in ein einzelnes Commit zerlegen möchten (z. B. wenn Sie ein Projekt zum ersten Mal öffentlich veröffentlichen), versuchen Sie Folgendes:

git checkout --orphan <new-branch>
git commit

2020 Einfache Lösung ohne Rebase:

git reset --soft HEAD~2

git commit -m "new commit message"

git push --force

2 bedeutet, dass die letzten beiden Commits gequetscht werden. Sie können es durch eine beliebige Nummer ersetzen

Ich denke, der einfachste Weg, dies zu tun, besteht darin, einen neuen Zweig aus dem Master zu machen und einen Merge-Quash des Feature-Zweigs durchzuführen.

git checkout master
git checkout -b feature_branch_squashed
git merge --squash feature_branch

Dann haben Sie alle Änderungen bereit, um festzuschreiben.

Einfacher Einzeiler, der immer funktioniert, vorausgesetzt, Sie befinden sich derzeit in dem Zweig, den Sie quetschen möchten, Master ist der Zweig, aus dem er stammt, und das letzte Commit enthält die Commit-Nachricht und den Autor, den Sie verwenden möchten:

git reset --soft $(git merge-base HEAD master) && git commit --reuse-message=HEAD@{1}

Wenn Sie beispielsweise die letzten 3 Commits für ein einzelnes Commit in einem Zweig (Remote-Repository) quetschen möchten, zum Beispiel: Bedingungen https://bitbucket.org

Was ich getan habe ist

1. Git Reset - Soft Head ~ 3 &&
2. Git Commit
3. git push origin (branch_name) --force

⚠️ WARNUNG: "Meine letzten X-Commits" sind möglicherweise nicht eindeutig.

  (MASTER)  
Fleetwood Mac            Fritz
      ║                    ║
  Add Danny  Lindsey     Stevie       
    Kirwan  Buckingham    Nicks                                              
      ║         ╚═══╦══════╝     
Add Christine       ║          
   Perfect      Buckingham
      ║           Nicks            
    LA1974══════════╝                                    
      ║                  
      ║                  
    Bill <══════ YOU ARE EDITING HERE
  Clinton        (CHECKED OUT, CURRENT WORKING DIRECTORY)              

In dieser sehr verkürzten Historie des Repositorys https://github.com/fleetwood-mac/band-history haben Sie eine Pull-Anfrage geöffnet, um das Bill Clinton-Commit mit dem Original zusammenzuführen (MASTER ) Fleetwood Mac-Commit zusammenzuführen.

Sie haben eine Pull-Anfrage geöffnet und auf GitHub sehen Sie Folgendes:

Vier Commits:

• Fügen Sie Danny Kirwan hinzu
• Fügen Sie Christine Perfect hinzu
• LA1974
• Bill Clinton

Ich denke, dass es niemanden interessieren würde, den vollständigen Repository-Verlauf zu lesen. (Es gibt tatsächlich ein Repository, klicken Sie auf den Link oben!) Sie beschließen, diese Commits zu quetschen. Also gehst du und rennst git reset --soft HEAD~4 && git commit. Dann Siegit push --force es auf GitHub, um deine PR aufzuräumen.

Und was passiert? Sie haben gerade eine einzige Verpflichtung eingegangen, die von Fritz zu Bill Clinton führt. Weil Sie vergessen haben, dass Sie gestern an der Buckingham Nicks-Version dieses Projekts gearbeitet haben. Und git logstimmt nicht mit dem überein, was Sie auf GitHub sehen.

🐻 MORAL DER GESCHICHTE

1. Finden Sie die genauen Dateien , die Sie erhalten möchten zu , undgit checkout sie
2. Finden Sie das genaue vorherige Commit, das Sie in der Historie behalten möchten, und git reset --soft das
3. Machen Sie eine git commit, die sich direkt von von nach nach oben verzieht

Wenn Sie sich nicht für die Commit-Nachrichten der Zwischen-Commits interessieren, können Sie diese verwenden

git reset --mixed <commit-hash-into-which-you-want-to-squash>
git commit -a --amend

Wenn Sie mit GitLab arbeiten, können Sie einfach auf die Squash-Option in der Zusammenführungsanforderung klicken, wie unten gezeigt. Die Festschreibungsnachricht ist der Titel der Zusammenführungsanforderung.

git rebase -i HEAD^^

wobei die Anzahl der ^ 's X ist

(In diesem Fall quetschen Sie die beiden letzten Commits.)

Zusätzlich zu anderen hervorragenden Antworten möchte ich hinzufügen, wie git rebase -imich immer mit der Festschreibungsreihenfolge verwechselt wird - älter als neuere oder umgekehrt? Das ist also mein Workflow:

1. git rebase -i HEAD~[N], wobei N die Anzahl der Commits ist, an denen ich teilnehmen möchte, beginnend mit dem letzten . Damitgit rebase -i HEAD~5 würde bedeuten , „quetscht die letzten 5 Commits in einen neuen“;
2. Der Editor wird angezeigt und zeigt die Liste der Commits an, die ich zusammenführen möchte. Jetzt werden sie in umgekehrter Reihenfolge angezeigt : Das ältere Commit befindet sich oben. Markieren Sie alle Commits mit Ausnahme des ersten / älteren als "Squash" oder "s" : Sie werden als Ausgangspunkt verwendet. Speichern und schließen Sie den Editor.
3. Der Editor wird erneut mit einer Standardmeldung für das neue Commit angezeigt: Ändern Sie sie nach Ihren Wünschen, speichern und schließen Sie sie. Squash abgeschlossen!

Quellen & zusätzliche Lesungen: # 1 , # 2 .

Was ist mit einer Antwort auf die Frage zu einem solchen Workflow?

1. Viele lokale Commits, gemischt mit mehreren Zusammenführungen vom Master ,
2. endlich ein Push zur Fernbedienung,
3. PR und Merge TO Master vom Reviewer . (Ja, es wäre für den Entwickler einfacher, merge --squashnach der PR zu arbeiten, aber das Team dachte, dies würde den Prozess verlangsamen.)

Ich habe auf dieser Seite keinen solchen Workflow gesehen. (Das können meine Augen sein.) Wenn ich rebaserichtig verstehe , würden mehrere Zusammenführungen mehrere Konfliktlösungen erfordern . Ich möchte nicht einmal darüber nachdenken!

Das scheint also für uns zu funktionieren.

1. git pull master
2. git checkout -b new-branch
3. git checkout -b new-branch-temp
4. viel lokal bearbeiten und festschreiben, Master regelmäßig zusammenführen
5. git checkout new-branch
6. git merge --squash new-branch-temp // setzt alle Änderungen in die Bühne
7. git commit 'one message to rule them all'
8. git push
9. Der Prüfer macht PR und verschmilzt zum Master.

Ich finde, eine allgemeinere Lösung besteht nicht darin, 'N'-Commits anzugeben, sondern die Verzweigungs- / Commit-ID, auf die Sie quetschen möchten. Dies ist weniger fehleranfällig als das Zählen der Festschreibungen bis zu einem bestimmten Festschreiben. Geben Sie das Tag einfach direkt an, oder wenn Sie wirklich zählen möchten, können Sie HEAD ~ N angeben.

In meinem Workflow starte ich einen Zweig, und mein erstes Commit für diesen Zweig fasst das Ziel zusammen (dh es ist normalerweise das, was ich als "endgültige" Nachricht für das Feature an das öffentliche Repository senden werde.) Wenn ich also fertig bin, alles Ich möchte tun ist git squash master zurück zur ersten Nachricht und dann bin ich bereit zu pushen.

Ich benutze den Alias:

squash = !EDITOR="\"_() { sed -n 's/^pick //p' \"\\$1\"; sed -i .tmp '2,\\$s/^pick/f/' \"\\$1\"; }; _\"" git rebase -i

Dadurch wird der gequetschte Verlauf zuvor gelöscht. Dies gibt Ihnen die Möglichkeit, ihn wiederherzustellen, indem Sie eine alte Festschreibungs-ID von der Konsole abrufen, wenn Sie zurücksetzen möchten. (Solaris-Benutzer beachten, dass die GNU sed- -iOption verwendet wird. Mac- und Linux-Benutzer sollten damit einverstanden sein.)

In Frage könnte es mehrdeutig sein, was mit "zuletzt" gemeint ist.

git log --graphgibt beispielsweise Folgendes aus (vereinfacht):

* commit H0
|
* merge
|\
| * commit B0
| |
| * commit B1
| | 
* | commit H1
| |
* | commit H2
|/
|

Dann sind die letzten Commits nach Zeit H0, Merge, B0. Um sie zu quetschen, müssen Sie Ihren zusammengeführten Zweig auf Commit H1 neu gründen.

Das Problem ist, dass H0 H1 und H2 enthält (und im Allgemeinen mehr Commits vor dem Zusammenführen und nach dem Verzweigen), während B0 dies nicht tut. Sie müssen also mindestens Änderungen von H0, Merge, H1, H2, B0 verwalten.

Es ist möglich, Rebase zu verwenden, jedoch auf andere Weise als in anderen genannten Antworten:

rebase -i HEAD~2

Dies zeigt Ihnen Auswahlmöglichkeiten (wie in anderen Antworten erwähnt):

pick B1
pick B0
pick H0

Setzen Sie Squash statt Pick auf H0:

pick B1
pick B0
s H0

Nach dem Speichern und Beenden werden bei Rebase nach H1 nacheinander Commits angewendet. Das bedeutet, dass Sie aufgefordert werden, Konflikte erneut zu lösen (wobei HEAD zuerst H1 ist und dann Commits ansammelt, wenn sie angewendet werden).

Nach Abschluss der Rebase können Sie eine Nachricht für die gequetschten H0 und B0 auswählen:

* commit squashed H0 and B0
|
* commit B1
| 
* commit H1
|
* commit H2
|

PS Wenn Sie nur einen Reset auf BO durchführen: (Dies wird beispielsweise reset --mixedhier unter https://stackoverflow.com/a/18690845/2405850 näher erläutert. )

git reset --mixed hash_of_commit_B0
git add .
git commit -m 'some commit message'

Dann quetschen Sie sich in B0-Änderungen von H0, H1, H2 (der Verlust geht vollständig für Änderungen nach der Verzweigung und vor dem Zusammenführen über.

1) git reset --soft HEAD ~ n

n - Nummer des Commits, muss gequetscht werden

2) git commit -m "neue Festschreibungsnachricht"

3) git push origin branch_name --force