Squash my last x commits together using Git

Można to zrobić dość łatwo bez git rebase lub git merge --squash. W tym przykładzie zmiażdżymy Ostatnie 3 commity.

Jeśli chcesz napisać nową wiadomość od zera, wystarczy:

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

Jeśli chcesz zacząć edytować nowy commit z połączeniem istniejących komunikatów commit( tj. podobnych do tych, które rozpoczynałaby lista instrukcji pick / squash/squash / ... / squash git rebase -i), musisz wyodrębnić te wiadomości i przekazać je do git commit:

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

Obie te metody rozkładają trzy ostatnie commity w jeden nowy commit w ten sam sposób. Miękki reset po prostu ponownie wskazuje głowę do ostatniego commita, którego nie chcesz zgnieść. Ani indeks, ani drzewo robocze nie zostaną dotknięte przez miękki reset, pozostawiając indeks w pożądanym stanie dla nowego commita(tzn. zawiera już wszystkie zmiany z commitów, które masz zamiar "wyrzucić").

Możesz użyć git merge --squash do tego, co jest nieco bardziej eleganckie niż git rebase -i. Załóżmy, że jesteś na master i chcesz zmiażdżyć Ostatnie 12 commitów w jeden.

WARNING: First make sure you commit your work-check that git status is clean (since git reset --hard will throw away staged and unstaged changes)

Wtedy:

# 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

Dokumentacja dla git merge opisuje bardziej szczegółowo opcję --squash.

Update: jedyną realną zaletą tej metody nad prostsza git reset --soft HEAD~12 && git commit zasugerowana przez Chrisa Johnsena w jego odpowiedź jest taka, że otrzymujesz wiadomość zatwierdzającą z góry przy każdej wiadomości zatwierdzającej, którą zgniatasz.

Zalecam unikanie git reset, gdy jest to możliwe-szczególnie dla nowicjuszy Gita. O ile nie musisz automatyzować procesu opartego naliczbie commitów, istnieje mniej egzotyczny sposób...

1. Umieść zmiażdżone commity na działającej gałęzi (jeśli jeszcze nie są) -- użyj gitk do tego
2. Sprawdź gałąź docelową (np.'master')
3. git merge --squash (working branch name)
4. git commit

Komunikat commit zostanie wstępnie wypełniony na podstawie squasha.

Na podstawie odpowiedzi Chrisa Johnsena ,

Dodaj globalny alias "squash" z Basha: (lub Git Bash na 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'

... lub za pomocą wiersza poleceń systemu 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"

Twój ~/.gitconfig powinien teraz zawierać ten alias:

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

Sposób użycia:

git squash N

... Który automatycznie zgniata ostatnie N commity, włącznie.

Uwaga: wynikowy komunikat commit jest kombinacją wszystkich zgniecionych commitów w kolejności. Jeśli jesteś niezadowolony z tego, zawsze możesz git commit --amend zmodyfikować go ręcznie. (Lub edytuj alias, aby dopasować go do swoich upodobań.)

Dzięki ten przydatny wpis na blogu odkryłem, że możesz użyć tej komendy do squasha ostatnich 3 commitów:

git rebase -i HEAD~3

Jest to przydatne, ponieważ działa nawet wtedy, gdy jesteś w lokalnym oddziale bez informacji o śledzeniu/zdalnego repo.

Polecenie otworzy interaktywny edytor rebase, który następnie pozwala na zmianę kolejności, squash, reword itp.

Korzystanie z interaktywnego edytora rebase:

Interaktywny edytor rebase pokazuje ostatnie trzy commity. Ograniczenie to zostało określone przez HEAD~3 podczas uruchamiania polecenia git rebase -i HEAD~3.

Ostatni commit, HEAD, jest wyświetlany jako pierwszy w linii 1. Linie zaczynające się od # to Komentarze/dokumentacja.

Wyświetlana dokumentacja jest dość przejrzysta. W dowolnej linii możesz zmienić polecenie z pick na dowolne polecenie.

Wolę użyć polecenia fixup ponieważ to "zgniata" zmiany commita w commicie w linii powyżej i odrzuca wiadomość commita.

Ponieważ commit w linii 1 to HEAD, w większości przypadków zostawisz to jako pick. Nie możesz użyć squash ani fixup, ponieważ nie ma innego commita, który mógłby go zmiażdżyć.

Jeśli używasz TortoiseGit, możesz użyć funkcji Combine to one commit:

1. Otwórz menu kontekstowe TortoiseGit
2. Wybierz Show Log
3. zaznacz odpowiednie zmiany w widoku dziennika
4. Wybierz Combine to one commit z menu kontekstowego

Ta funkcja automatycznie wykonuje wszystkie niezbędne pojedyncze kroki Gita. Niestety dostępne tylko dla Windows.

Na podstawie tego artykułu znalazłem tę metodę łatwiejszą dla mojego zastosowania.

Moja gałąź 'dev' wyprzedziła 'origin/dev' o 96 commitów (więc te commity nie zostały jeszcze wysłane do remote ' a).

Chciałem zmiażdżyć te commity w jeden przed przesunięciem zmiany. Preferuję zresetować gałąź do stanu 'origin/dev' (spowoduje to pozostawienie wszystkich zmian z 96 commitów bez zmian), a następnie zatwierdzić zmiany na raz:

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

1) Zidentyfikuj krótki hash commit

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

Tutaj nawet git log --oneline można również użyć do uzyskania krótkiego skrótu.

2) Jeśli chcesz zmiażdżyć (połączyć) ostatnie dwa commity

# git rebase -i deab3412 

3) otwiera edytor nano do scalania. I wygląda to tak jak poniżej

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

4) Zmień nazwę słowa pick na squash, które występuje przed abcd1234. Po zmianie nazwy powinna być jak poniżej.

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

5) Teraz zapisz i zamknij Edytor nano. Naciśnij ctrl + o i naciśnij Enter, aby zapisać. I wtedy naciśnij ctrl + x, aby zamknąć Edytor.

6) Następnie nano edytor ponownie otwiera się w celu aktualizacji komentarzy, jeśli to konieczne, zaktualizuj je.

7) teraz jego zgnieciony pomyślnie, można go zweryfikować, sprawdzając dzienniki.

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

8) Teraz naciśnij do repo. Uwaga, aby dodać znak + przed nazwą gałęzi. Oznacza to wymuszone pchnięcie.

# git push origin +master

Uwaga: jest to oparte na użyciu git na ubuntu powłoce. Jeśli używasz innego systemu operacyjnego (Windows lub Mac), powyższe polecenia są takie same, z wyjątkiem edytora. Możesz znajdź innego redaktora.

W tym celu możesz użyć polecenia git.

 git rebase -i HEAD~n

N(=4 tutaj) to liczba ostatnich zmian. Następnie masz następujące opcje,

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

Update like bellow,

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

Po szczegóły kliknij na Link

Jeśli znajdujesz się w zdalnej gałęzi (o nazwie feature-branch) sklonowanej ze Złotego repozytorium (golden_repo_name), Oto technika zgniatania commitów w jeden:

1. Checkout the golden repo

   git checkout golden_repo_name
   

2. Utwórz z niego nową gałąź (golden repo) w następujący sposób

   git checkout -b dev-branch
   

3. Squash połącz się z lokalnym oddziałem, który już masz

   git merge --squash feature-branch
   

4. Zatwierdź zmiany (będzie to jedyny commit, który zostanie wprowadzony dev-branch)

   git commit -m "My feature complete"
   

5. Przesuń gałąź do lokalnego repozytorium

   git push origin dev-branch
   

Odpowiedź jest dobra, ale czułem się niepewnie, więc postanowiłem dodać kilka screenów.

Krok 0: Git log

Zobacz, gdzie jesteś z git log. Najważniejsze, znajdź hash commit pierwszego commita nie, który chcesz zmiażdżyć. Więc tylko:

Krok 1: Git rebase

Wykonaj git rebase -i [your hash], w moim przypadku:

$ git rebase -i 2d23ea524936e612fae1ac63c95b705db44d937d

Krok 2: Wybierz / squash co chcesz

W moim przypadku, chcę / align = "center" bgcolor = "# e0ffe0 " / cesarz chin / / align = center / Kolejność jest od pierwszego do ostatniego, więc dokładnie w drugą stronę jak w git log. W moim przypadku chcę:

Krok 3: Dostosuj wiadomość(y)

Jeśli wybrałeś tylko jeden commit i zmiażdżyłeś resztę, możesz dostosować jeden commit:

To jest super-duper kludgy, ale w jakiś fajny sposób, więc wrzucę to na 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

Translation: podaj nowy "edytor" dla Gita, który, jeśli nazwa pliku do edycji to git-rebase-todo (interaktywny monit rebase) zmienia wszystkie oprócz pierwszego "pick" na "squash" , a w przeciwnym razie wyświetla Vima - tak, że kiedy zostaniesz poproszony o edycję squashed commit, otrzymasz Vima. (I oczywiĹ "cie zgniataĺ' em ostatnie 5 commitów na branchu foo, ale moĹźna to jednak zmieniÄ ‡ na przykład.)

Jeśli chcesz zmiksować każdy commit w jeden commit (np. podczas publikowania projektu po raz pierwszy), spróbuj:

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

Co może być naprawdę wygodne: Znajdź hash commit, na którym chcesz zmiażdżyć; powiedz, że to d43e15 Teraz Użyj

git reset d43e15

git commit -am 'new commit name'

Myślę, że najprostszym sposobem na to jest utworzenie nowej gałęzi z master i wykonanie merge -- squash z gałęzi feature.

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

Wtedy masz wszystkie zmiany gotowe do zatwierdzenia.

Uważam, że bardziej ogólnym rozwiązaniem nie jest podanie' N ' commitów, ale raczej gałąź / commit-id, na którym chcesz się zgnieść. Jest to mniej podatne na błędy niż zliczanie commitów do konkretnego commita-po prostu określ tag bezpośrednio lub jeśli naprawdę chcesz zliczyć, możesz podać HEAD~n.

W moim obiegu pracy uruchamiam gałąź, a mój pierwszy commit na tej gałęzi podsumowuje cel (tzn. zazwyczaj jest to komunikat "końcowy" dla danej funkcji do publicznego repozytorium.) So kiedy skończę, wszystko, co chcę zrobić, to wrócić do pierwszej wiadomości, a potem jestem gotowy do pchnięcia.

Używam pseudonimu:

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

Spowoduje to zrzut historii, która została zgnieciona, zanim to zrobi-daje to szansę na odzyskanie przez pobranie starego identyfikatora commita z konsoli, jeśli chcesz przywrócić. (Użytkownicy Solarisa zauważają, że używa opcji GNU sed -i, użytkownicy komputerów Mac i Linuksa powinni się z tym pogodzić.)

W pytaniu może być niejednoznaczne, co oznacza "ostatni".

Na przykład git log --graph wypisuje następujące (uproszczone):

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

Ostatnie commity według czasu to H0, merge, B0. Aby je zmiażdżyć, będziesz musiał zmienić swoją połączoną gałąź na commit H1.

Problem polega na tym, że H0 zawiera H1 i H2 (i ogólnie więcej commitów przed scaleniem i po rozgałęzieniu), podczas gdy B0 nie. więc musisz zarządzać zmianami z H0, merge, H1, H2, B0 przynajmniej.

Możliwe jest użycie rebase, ale w inny sposób niż w innych wymienionych odpowiedzi:

rebase -i HEAD~2

To pokaże Ci opcje wyboru (jak wspomniano w innych odpowiedziach):

pick B1
pick B0
pick H0

Put squash zamiast pick to H0:

pick B1
pick B0
s H0

Po zapisaniu i zakończeniu rebase zastosuje commity z kolei po H1. Oznacza to, że poprosi Cię o ponowne rozwiązywanie konfliktów (gdzie HEAD będzie najpierw H1, a następnie kumuluje commity podczas ich stosowania).

Po zakończeniu rebase możesz wybrać wiadomość dla zgniecionych H0 i B0:

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

P. S. Jeśli zrobisz jakiś reset do BO: (na przykład, używając reset --mixed, które jest wyjaśnione bardziej szczegółowo tutaj https://stackoverflow.com/a/18690845/2405850):

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

Następnie rozkładasz na B0 zmiany H0, H1, H2 (tracąc całkowicie commity dla zmian po rozgałęzieniu i przed scaleniem.

git rebase -i HEAD^^

Gdzie liczba ^ ' s to X

(w tym przypadku squash dwóch ostatnich commitów)

Spójrz na ten gist:

Gist-Easy git-squash

Musisz wpisać np. git-squash 3 i tyle. Ostatnie trzy commity połączyły się w jeden, a ich wiadomości zostały skonkatenowane.

Oprócz innych doskonałych odpowiedzi, chciałbym dodać, jak git rebase -i zawsze myli mnie z kolejnością commitów-starszą na nowszą czy odwrotnie? Więc to jest mój workflow:

1. git rebase -i HEAD~[N], gdzie N jest liczbą commitów, które chcę dołączyć, począwszy od ostatniego . Więc git rebase -i HEAD~5 oznaczałoby "squash the last 5 commits into a new one";
2. pojawi się edytor, pokazujący listę commitów, które chcę scalić. Teraz są wyświetlane w odwrotnej kolejności : starsze commit jest na szczycie. Zaznacz jako" squash "lub" s " wszystkie commity z wyjątkiem pierwszego/starszego: zostanie użyty jako punkt wyjścia. Zapisz i zamknij Edytor;
3. edytor pojawia się ponownie z domyślnym Komunikatem dla nowego commita: zmień go do swoich potrzeb, Zapisz i zamknij. Squash zakończony!

Źródła i dodatkowe odczyty: #1, #2.

Aby podzielić ostatnie 10 commitów na jeden commit:

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

Jeśli chcesz również zaktualizować zdalną gałąź za pomocą squashed commit:

git push -f

W gałęzi, w której chcesz połączyć commity, Uruchom:

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

Otworzy to edytor tekstu i musisz przełączyć 'pick' przed każdym commitem na 'squash', jeśli chcesz, aby te commity zostały połączone razem. Na przykład, jeśli chcesz połączyć wszystkie commity w jeden, 'pick' jest pierwszym commitem, który zrobiłeś i wszystkie przyszłe (umieszczone poniżej pierwszego) powinny być ustawione na 'squash'. Jeśli używasz Vima, użyj :x w trybie wstawiania, aby zapisać i zakończyć redaktor.

Następnie zakończyć rebase:

git rebase --continue

Aby dowiedzieć się więcej o tym i innych sposobach przepisania historii zmian zobacz ten pomocny post

A co z odpowiedzią na pytanie związane z takim przepływem pracy?

1. wiele lokalnych commitów, zmieszanych z wieloma mergami z master ,
2. wreszcie push to remote,
3. PR i merge to master by reviewer. (Tak, deweloperowi byłoby łatwiej merge --squash po PR, ale zespół myślał, że to spowolni proces.)

1. git pull master
2. git checkout -b new-branch
3. git checkout -b new-branch-temp
4. Edytuj i zatwierdzaj wiele lokalnie, Scal master regularnie
5. git checkout new-branch
6. git merge --squash new-branch-temp / / umieszcza wszystkie zmiany w scenie
7. git commit 'one message to rule them all'
8. git push
9. recenzent robi PR i łączy się z mistrzem.

Jeśli używasz GitUp, Wybierz commit, który chcesz scalić z jego rodzicem i naciśnij S. Musisz to zrobić raz dla każdego commita, ale jest to o wiele prostsze niż wymyślenie poprawnej inkantacji wiersza poleceń. Zwłaszcza, jeśli robisz to tylko raz na jakiś czas.

Wystarczy dodać tę funkcję bash do bash z .plik zshrc.

# Squash last X commits with a Commit message.
# Usage: squash X 'COMMIT_MSG'
# where X= Number of last commits.
# where COMMIT_MSG= New commit msg.
function squash() {
    if [ -z "${1}" -o -z "${2}" ]; then
        echo "Usage: \`squash X COMMIT_MSG\`"
        echo "X= Number of last commits."
        echo "COMMIT_MSG= New commit msg."
        return 1
    fi

    git reset --soft HEAD~"$1"
    git add . && git ci -m "$2" # With 100 emoji
    git push --force
}

Then just run

squash X 'New Commit Message'

Innym sposobem, aby to zrobić, jeśli masz mnóstwo commitów, jest wykonanie squasha po commicie, takim jak git rebase -i <hashbeforeyouwanttosquash>

To otworzy twój edytor, aby wybrać / squash jak zwykle.

Zobacz https://git-scm.com/docs/git-rebase#_interactive_mode

Najpierw ustalam liczbę commitów pomiędzy moją gałęzią feature i bieżącą gałęzią master przez

git checkout master
git rev-list master.. --count

Następnie, tworzę kolejną gałąź opartą na mojej gałęzi-feature, pozostaw my-feature gałąź nietkniętą.

Wreszcie biegnę

git checkout my-feature
git checkout -b my-rebased-feature
git checkout master
git checkout my-rebased-feature
git rebase master
git rebase head^x -i
// fixup/pick/rewrite
git push origin my-rebased-feature -f // force, if my-rebased-feature was ever pushed, otherwise no need for -f flag
// make a PR with clean history, delete both my-feature and my-rebased-feature after merge

Przełącz się do gałęzi master i upewnij się, że jesteś na bieżąco:

sh git checkout master && git fetch && git pull

Połącz swoją gałąź feature do gałęzi master lokalnie:

sh git merge feature_branch

Zresetuj lokalną gałąź master do stanu origin:

sh git reset origin/master

Teraz wszystkie twoje zmiany są uważane za zmiany nieagresywne. Możesz ustawić i zatwierdzić je w jeden lub więcej commitów.

sh git add . --all git commit