Jak zmodyfikować określony commit?

Użyj niesamowitego interaktywnego rebase:

git rebase -i @~9   # Show the last 9 commits in a text editor

Znajdź odpowiedni commit, Zmień pick na e (edit), i zapisz i zamknij plik. Git będzie przewijał do tego commita, pozwalając na:

• użyj git commit --amend do wprowadzania zmian lub
• użyj git reset @~, aby odrzucić ostatni commit, ale nie zmiany w plikach (tzn. przeniesie Cię do punktu, w którym edytowałeś pliki, ale jeszcze nie zatwierdziłeś).

Ten ostatni jest przydatny do wykonywania bardziej złożonych takie rzeczy jak dzielenie na wiele commitów.

Następnie uruchom git rebase --continue, a Git odtworzy kolejne zmiany na Twoim zmodyfikowanym commicie. Możesz zostać poproszony o naprawienie niektórych konfliktów scalania.

Uwaga: @ jest skrótem od HEAD, a {[10] } jest zatwierdzeniem przed podanym zatwierdzeniem.

Przeczytaj więcej o przepisywaniu historii w dokumentacji Git.

Nie bój się rebase

ProTip™: nie bój się eksperymentować z "niebezpieczne" polecenia, które przepisują historię * - Git domyślnie nie usuwa Twoich commitów przez 90 dni; możesz je znaleźć w reflogu:

$ git reset @~3   # go back 3 commits
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~3
2c52489 HEAD@{1}: commit: more changes
4a5246d HEAD@{2}: commit: make important changes
e8571e4 HEAD@{3}: commit: make some changes
... earlier commits ...
$ git reset 2c52489
... and you're back where you started

* uważaj jednak na opcje takie jak --hard i --force - mogą one odrzucić dane.
* nie zapisuj również historii w żadnych gałęziach, nad którymi współpracujesz.

Na wielu systemach, git rebase -i domyślnie otworzy Vima. Vim nie działa jak większość nowoczesnych edytorów tekstu, więc spójrz na jak rebase korzystanie z Vim . Jeśli wolisz używać innego edytora, zmień go za pomocą git config --global core.editor your-favorite-text-editor.

Interactive rebase with --autosquash jest czymś, czego często używam, gdy muszę naprawić poprzednie commity głębiej w historii. Zasadniczo przyspiesza proces, który ilustruje odpowiedź ZelluX, i jest szczególnie przydatny, gdy masz więcej niż jeden commit, który musisz edytować.

Z dokumentacji:

--autosquash

Gdy komunikat dziennika zmian zaczyna się od " squash! ... "(lub "fixup! ... "), a istnieje commit, którego tytuł zaczyna się od tego samego …​, automatycznie Modyfikuj listę todo rebase-i tak, aby commit oznaczony do squashowania pojawił się zaraz po commicie, który ma zostać zmodyfikowany

Załóżmy, że masz historię, która wygląda tak:

$ git log --graph --oneline
* b42d293 Commit3
* e8adec4 Commit2
* faaf19f Commit1

I masz zmiany, które chcesz zmienić w commit 2, a następnie zatwierdź zmiany za pomocą

$ git commit -m "fixup! Commit2"

Alternatywnie możesz użyć commit-sha zamiast komunikatu commit, więc "fixup! e8adec4 lub nawet tylko prefiks komunikatu commit.

Następnie zainicjuj interaktywną rebazę na commit przed

$ git rebase e8adec4^ -i --autosquash

Twój edytor otworzy się z poprawnym zatwierdzeniem

pick e8adec4 Commit2
fixup 54e1a99 fixup! Commit2
pick b42d293 Commit3

Wszystko, co musisz zrobić, to zapisać i zakończyć

Run:

$ git rebase --interactive commit_hash^

Każdy ^ wskazuje, ile commitów chcesz edytować, jeśli jest to tylko jeden (hash commitów, który podałeś), to po prostu dodajesz jeden ^.

Używając Vima zmieniasz słowa pick na reword dla commitów, które chcesz zmienić, Zapisz i zakończ(:wq). Następnie git wyświetli monit z każdym zatwierdzeniem, które zostało oznaczone jako przeredagowanie, abyś mógł zmienić wiadomość zatwierdzania.

Każda wiadomość commit musisz zapisać i zamknąć (:wq) aby przejść do następnego commit message

Jeśli chcesz wyjść bez stosowania zmian, naciśnij :q!

EDIT: aby nawigować w vim, używasz j, aby przejść do góry, k, aby przejść do dołu, h, aby przejść do lewej i l, aby przejść do trybu NORMAL). Aby edytować tekst, naciśnij i, aby przejść do trybu INSERT, w którym wstawiasz tekst. Naciśnij ESC, aby wrócić do trybu NORMAL:)

UPDATE : oto świetny link z github listing jak cofnąć (prawie) wszystko z git

Na podstawie dokumentacji

Zmiana wiadomości starszych lub wielu komunikatów commit

git rebase -i HEAD~3 

Powyższe wyświetla listę ostatnich 3 commitów w bieżącej gałęzi, Zmień 3 na coś innego, jeśli chcesz więcej. Lista będzie wyglądać podobnie do:

pick e499d89 Delete CNAME
pick 0c39034 Better README
pick f7fde4a Change the commit message but push the same commit.

Zastąp pick z przeredaguj przed każdą wiadomością commit, którą chcesz zmienić. Powiedzmy, że zmienisz drugi commit na liście, Twój plik będzie wyglądał jak "po": {]}

pick e499d89 Delete CNAME
reword 0c39034 Better README
pick f7fde4a Change the commit message but push the same commit.

Zapisz i zamknij plik listy zatwierdzeń, pojawi się nowy edytor, aby zmienić wiadomość zatwierdzania, zmienić wiadomość zatwierdzania i zapisać.

Ostatecznie Wymuś-wciśnij zmienione commity.

git push --force

Jeśli z jakiegoś powodu nie lubisz edytorów interaktywnych, możesz użyć git rebase --onto.

Powiedz, że chcesz zmodyfikować Commit1. Najpierw gałąź z przed Commit1:

git checkout -b amending [commit before Commit1]

Drugi, chwyć Commit1 z cherry-pick:

git cherry-pick Commit1

Teraz popraw swoje zmiany, tworząc Commit1':

git add ...
git commit --amend -m "new message for Commit1"

I na koniec, po ukryciu wszelkich innych zmian, przenieś resztę commitów do master na wierzch nowy commit:

git rebase --onto amending Commit1 master

Powinno być: "rebase, na gałęzi amending, wszystkie committs between Commit1 (non-inclusive) and master (inclusive)". Oznacza to, że commit 2 I commit 3, całkowicie odcinając Stary commit 1. Możesz je po prostu wybrać, ale ten sposób jest łatwiejszy.

Pamiętaj, aby oczyścić swoje gałęzie!

git branch -d amending

Całkowicie nieinteraktywne polecenie⁽¹⁾

git config --global alias.amend-to '!f() { SHA=`git rev-parse "$1"`; git commit --fixup "$SHA" && GIT_SEQUENCE_EDITOR=true git rebase --interactive --autosquash "$SHA^"; }; f'

git config --global alias.amend-to '!f() { SHA=`git rev-parse "$1"`; git stash -k && git commit --fixup "$SHA" && GIT_SEQUENCE_EDITOR=true git rebase --interactive --autosquash "$SHA^" && git stash pop; }; f'

Największą zaletą tego polecenia jest fakt, że jest no-vim.

⁽¹⁾biorąc pod uwagę, że nie ma konfliktów podczas rebase, oczywiście

Użycie

git amend-to <REV> # e.g.
git amend-to HEAD~1
git amend-to aaaa1111

Nazwa amend-to wydaje się odpowiednia IMHO. Porównaj przepływ z --amend:

git add . && git commit --amend --no-edit
# vs
git add . && git amend-to <REV>

Wyjaśnienie

• git config --global alias.<NAME> '!<COMMAND>' - tworzy globalny alias git o nazwie <NAME>, który wykona polecenie inne niż git <COMMAND>
• f() { <BODY> }; f - "anonimowa" funkcja bash.
• SHA=`git rev-parse "$1"`; - Konwertuje argument do git revision i przypisuje wynik do zmienna SHA
• git commit --fixup "$SHA" - fixup-commit dla SHA. Zobacz też git-commit docs
• GIT_SEQUENCE_EDITOR=true git rebase --interactive --autosquash "$SHA^"
  • git rebase --interactive "$SHA^" część została pokryta innymi odpowiedziami.
  • --autosquash jest to, co jest używane w połączeniu z git commit --fixup, zobacz git-rebase docs aby uzyskać więcej informacji
  • To sprawia, że całość nie jest interaktywna. Tego hacka nauczyłem się Z tego posta na blogu .

Automatyczna, interaktywna edycja rebase, po której następuje commit revert gotowy do powtórzenia

Znalazłem się naprawiając poprzedni commit na tyle często, że napisałem do niego skrypt.

Oto przebieg pracy:

1. git commit-edit <commit-hash>
   

   Spowoduje to usunięcie zmian, które chcesz edytować.

2. Popraw i ustaw commit tak, jak chcesz, aby był na pierwszym miejscu.

   (możesz użyć git stash save, Aby zachować pliki, których nie jesteś committing)

3. Powtórz commit za pomocą --amend, np:

   git commit --amend
   

4. Uzupełnij rebase:

   git rebase --continue
   

Aby powyższy skrypt zadziałał, umieść poniższy skrypt w pliku wykonywalnym o nazwie git-commit-edit gdzieś w twoim $PATH:

#!/bin/bash

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "$@"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")
message=$(git log -1 --format='%h %s' "$commit")

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo

git stash + rebase Automatyka

Na kiedy muszę modyfikować Stary commit wiele razy dla Gerrit reviews, robiłem:

git-amend-old() (
  # Stash, apply to past commit, and rebase the current branch on to of the result.
  current_branch="$(git rev-parse --abbrev-ref HEAD)"
  apply_to="$1"
  git stash
  git checkout "$apply_to"
  git stash apply
  git add -u
  git commit --amend --no-edit
  new_sha="$(git log --format="%H" -n 1)"
  git checkout "$current_branch"
  git rebase --onto "$new_sha" "$apply_to"
)

GitHub upstream .

Użycie:

• zmodyfikować plik źródłowy, nie trzeba git add jeśli już w repo
• git-amend-old $old_sha

Podoba mi się to nad --autosquash, ponieważ nie niszczy innych niepowiązanych poprawek.

Przyszedł do tego podejścia (i jest to prawdopodobnie dokładnie to samo, co za pomocą interaktywnego rebase), ale dla mnie jest to dość proste.

Uwaga: przedstawiam to podejście ze względu na ilustrację tego, co można zrobić, a nie codzienną alternatywę. Ponieważ ma wiele kroków (i ewentualnie pewne zastrzeżenia.)

Powiedz, że chcesz zmienić commit 0 i jesteś aktualnie na feature-branch

some-commit---0---1---2---(feature-branch)HEAD

Sprawdź ten commit i utwórz quick-branch. Możesz również sklonować swoją funkcję gałąź jako punkt regeneracji (przed rozpoczęciem).

?(git checkout -b feature-branch-backup)
git checkout 0
git checkout -b quick-branch

Teraz będziesz miał coś takiego:

0(quick-branch)HEAD---1---2---(feature-branch)

Zmiany sceny, Schowaj Wszystko inne.

git add ./example.txt
git stash

Zatwierdź zmiany i Kasuj z powrotem do feature-branch

git commit --amend
git checkout feature-branch

Teraz będziesz miał coś takiego:

some-commit---0---1---2---(feature-branch)HEAD
           \
             ---0'(quick-branch)

Rebase feature-branch na quick-branch (rozwiąż wszelkie konflikty po drodze). Apply stash and remove quick-branch.

git rebase quick-branch
git stash pop
git branch -D quick-branch

I kończy się na:

some-commit---0'---1'---2'---HEAD(feature-branch)

Git nie powieli (chociaż I nie mogę powiedzieć w jakim stopniu) 0 commit podczas rebasingu.

Uwaga: wszystkie skróty zmian są zmieniane począwszy od zmiany, którą pierwotnie zamierzaliśmy zmienić.

Aby uzyskać polecenie nieinteraktywne, umieść skrypt z tą zawartością w ścieżce:

#!/bin/sh
#
# git-fixup
# Use staged changes to modify a specified commit
set -e
cmt=$(git rev-parse $1)
git commit --fixup="$cmt"
GIT_EDITOR=true git rebase -i --autosquash "$cmt~1"

Użyj go przez inscenizację zmian (za pomocą git add), a następnie uruchom git fixup <commit-to-modify>. Oczywiście nadal będzie interaktywny, jeśli pojawią się konflikty.

I solved this,

1) tworząc nowy commit ze zmianami, które chcę..

r8gs4r commit 0

2) wiem, który commit muszę z nim połączyć. czyli commit 3.

Więc git rebase -i HEAD~4 # 4 reprezentuje ostatnie 4 commit (tutaj commit 3 jest na 4 miejscu)

3) w interaktywnym rebase Ostatnie zatwierdzenie będzie umieszczone na dole. będzie wyglądać podobnie,

pick q6ade6 commit 3
pick vr43de commit 2
pick ac123d commit 1
pick r8gs4r commit 0

4) tutaj musimy zmienić commit, jeśli chcemy połączyć się z konkretnym. powinno być tak:

parent
|_child

pick q6ade6 commit 3
f r8gs4r commit 0
pick vr43de commit 2
pick ac123d commit 1

Po przestawianiu Ciebie trzeba wymienić p pick z f (fixup połączy się bez komunikatu commit) lub s (squash merge with commit message can change in run time)

A następnie zapisać swoje drzewo.

Teraz połącz z istniejącym commitem.

Uwaga: nie jest to preferowana metoda, chyba że utrzymujesz ją samodzielnie. jeśli masz duży rozmiar zespołu to nie jest akceptowalna metoda przepisywania Gita drzewo skończy w konfliktach, które znasz inne zwyczaje. jeśli chcesz na utrzymanie drzewa czyste z mniej commitów może spróbować tego i jeśli jego mały zespół w przeciwnym razie nie jest preferowany.....

Najlepszą opcją jest użycie "interaktywnego polecenia rebase" .

git rebase komenda jest niezwykle potężna. Pozwala na edycję commit messages , combine commit, reorder them ...itd.

Za każdym razem, gdy przerobisz commit, tworzony będzie nowy SHA dla każdego commit niezależnie od zawartości zostanie zmieniony lub nie! Powinieneś być ostrożnie, kiedy użyć tego polecenia, ponieważ może mieć drastyczne implikacje szczególnie jeśli pracujesz w współpraca z innymi deweloperzy. Mogą zacząć pracować z Twoim commitem, gdy jesteś zmieniam trochę. Po wymusić wypchnięcie commitów będą z Synchronizuj i możesz dowiedzieć się później w brudnej sytuacji. Więc bądź ostrożny!

Zaleca się utworzenie backup gałęzi przed rebasingiem kiedy znajdziesz rzeczy poza kontrolą, możesz wrócić do poprzedni stan.

Jak użyć tego polecenia?

git rebase -i <base> 

-i stojak na "interaktywny" . Należy pamiętać, że rebase można wykonać w trybie nieinteraktywnym. ex:

#interactivly rebase the n commits from the current position, n is a given number(2,3 ...etc)
git rebase -i HEAD~n 

HEAD wskazuje aktualną lokalizację (może to być również nazwa gałęzi lub commit SHA). ~n oznacza "n przed, więc HEAD~n będzie listą" n " przed tym, na którym aktualnie się znajdujesz.

git rebase posiada inną komendę:

• p lub pick aby zachować commit tak, jak jest.
• r lub reword: Aby zachować zawartość commita, ale zmienić komunikat commita.
• s lub squash: aby połączyć zmiany tego commita z poprzednim commitem(commit znajdujący się nad nim na liście).

• ... itd.

  Uwaga: lepiej jest, aby Git pracował z Twoim edytorem kodu, aby wszystko było prostsze. Na przykład, jeśli używasz kodu wizualnego, możesz dodać w ten sposób git config --global core.editor "code --wait". Możesz też wyszukać w Google jak powiązać preferowany edytor kodu z Gitem.

Przykład git rebase

Chciałem zmienić ostatnie 2 commity Zrobiłem więc przetwarzam tak:

1. Wyświetla bieżące commity:

   #This to show all the commits on one line
   $git log --oneline
   4f3d0c8 (HEAD -> documentation) docs: Add project description and included files"
   4d95e08 docs: Add created date and project title"
   eaf7978 (origin/master , origin/HEAD, master) Inital commit
   46a5819 Create README.md
   

2. Teraz używam git rebase aby zmienić 2 ostatnie commity: $git rebase -i HEAD~2 Otwiera edytor kodu i pokazuje to:

   pick 4d95e08 docs: Add created date and project title
   pick 4f3d0c8 docs: Add project description and included files
   
   # Rebase eaf7978..4f3d0c8 onto eaf7978 (2 commands)
   #
   # Commands:
   # p, pick <commit> = use commit
   # r, reword <commit> = use commit, but edit the commit message
   ...
   

   Ponieważ chcę zmienić komunikat commit dla tych 2 commitów. Więc napiszę r lub reword w miejsce pick. Następnie zapisz plik i zamknij kartę. Zauważ, że {[27] } jest wykonywany w procesie wieloetapowym, więc następnym krokiem jest aktualizacja wiadomości. Należy również zauważyć, że commity są wyświetlane w odwrotnej kolejności chronologicznej, więc ostatni commit jest wyświetlany w tym, a pierwszy commit w pierwszej linii i tak dalej.

3. Zaktualizuj wiadomości: Zaktualizuj pierwszą wiadomość:

   docs: Add created date and project title to the documentation "README.md"
   
   # Please enter the commit message for your changes. Lines starting
   # with '#' will be ignored, and an empty message aborts the commit.
   ...
   

   Zapisz i zamknij Edycja drugiej wiadomości

   docs: Add project description and included files to the documentation "README.md"
   
   # Please enter the commit message for your changes. Lines starting
   # with '#' will be ignored, and an empty message aborts the commit.
   ...
   

   Zapisz i zamknij.

4. Otrzymasz taką wiadomość na końcu rebase: Successfully rebased and updated refs/heads/documentation co oznacza, że ci się uda. Możesz wyświetlić zmiany:

   5dff827 (HEAD -> documentation) docs: Add project description and included files to the documentation "README.md"
   4585c68 docs: Add created date and project title to the documentation "README.md"
   eaf7978 (origin/master, origin/HEAD, master) Inital commit
   46a5819 Create README.md
   

   Chciałbym to może pomóc nowym użytkownikom :).

Dla mnie to było za usunięcie niektórych poświadczeń z repo. Próbowałem rebasingu i napotkałem mnóstwo pozornie niepowiązanych konfliktów po drodze, próbując rebase -- Kontynuuj. Nie trudź się próbując rebase siebie, użyj narzędzia o nazwie BFG (brew install bfg) na mac.

Jeśli jeszcze nie wypchnąłeś commitów, możesz wrócić do poprzedniego commita używając git reset HEAD^[1,2,3,4...]

Na przykład

git commit <file1> -m "Updated files 1 and 2"
git commit <file3> -m "Updated file 3"

UPS, zapomniałem dodać file2 do pierwszego commita...

git reset HEAD^1 // because I only need to go back 1 commit

git add <file2>

Spowoduje dodanie file2 do pierwszego commita.

Cóż, to rozwiązanie może brzmieć bardzo głupio, ale może cię uratować w pewnych warunkach.

Mój znajomy wpadł na przypadkowo popełniając bardzo duże pliki (cztery automatycznie wygenerowane pliki od 3GB do 5Gb każdy), a następnie wykonał dodatkowe commity kodu, zanim zdał sobie sprawę, że git push nie działa już dłużej!

Pliki zostały wymienione w .gitignore ale po zmianie nazwy folderu kontenera zostały ujawnione i oddany! A teraz było jeszcze kilka commitów kodu, ale push działał w nieskończoność (próbując wgrać GB danych!) i ostatecznie zawiedzie z powodu ograniczeń rozmiaru pliku Githuba.

Problem z interaktywnym rebase ' em lub czymś podobnym polegał na tym, że zajmowaliby się grzebaniem w tych ogromnych plikach i zajmowaliby wieczność, aby cokolwiek zrobić. Niemniej jednak, po spędzeniu prawie godziny w CLI, nie byliśmy pewni, czy pliki (i delty) są rzeczywiście usuwane z historii lub po prostu nieuwzględnione w bieżących commitach. Pchnięcie też nie zadziałało, a mój przyjaciel naprawdę utknął.

Więc, rozwiązanie, które wymyśliłem było:

1. Zmień nazwę bieżącego folderu git na ~/Project-old.
2. ponownie Sklonuj folder git z github (do ~/Project).
3. Kasa do tego samego oddziału.
4. ręcznie cp -r pliki z folderu ~/Project-old do ~/Project.
5. upewnij się, że masywne pliki, które nie są potrzebne do sprawdzenia są mv, i zawarte w .gitignore odpowiednio.
6. upewnij się również, że nie Nadpisz .git folderu Ostatnio sklonowanego ~/Project przez stary. Tam żyją dzienniki problematycznej historii!
7. teraz przejrzyj zmiany. Powinno to być zjednoczenie wszystkich ostatnich commitów, z wyłączeniem problematycznych plików.
8. W końcu zatwierdź zmiany i dobrze jest być push'ed.

Największym problemem tego rozwiązania jest to, że zajmuje się ręcznym kopiowaniem niektórych plików, a także Scala wszystkie ostatnie commity w jeden (oczywiście z nowym skrótem commit-hash.) B

Dużą zaletą jest to, że jest to bardzo jasne na każdym kroku, działa świetnie dla dużych plików (jak również wrażliwych) i nie pozostawia po sobie żadnego śladu w historii!