Wiele skomplikowanych i niebezpiecznych odpowiedzi tutaj, ale to naprawdę łatwe:

git revert --no-commit 0766c053..HEAD
git commit

Spowoduje to przywrócenie wszystkich zmian z głowy do hash commit, co oznacza odtworzenie tego stanu w drzewie roboczym tak, jakby każdy commit po 0766c053 został przeniesiony z powrotem. Następnie możesz zatwierdzić obecne drzewo i utworzy ono zupełnie nowy commit, zasadniczo równoważny zatwierdzeniu, do którego "powróciłeś".

(znacznik --no-commit pozwala gitowi przywrócić wszystkie commity naraz- w przeciwnym razie zostaniesz poproszony o wiadomość dla każdego commita w zakresie, zaśmiecając swoją historię niepotrzebnymi nowymi commitami.)

To jest bezpieczny i łatwy sposób na przywrócenie poprzedniego stanu . Żadna historia nie została zniszczona, więc może być używana do commitów, które zostały już upublicznione.

Rogue Coder? Pracujesz na własną rękę i chcesz, żeby to zadziałało? Postępuj zgodnie z poniższymi instrukcjami, działają niezawodnie dla mnie i wielu innych od lat.

Przywracanie kopii roboczej do najnowszego Commita

Aby przywrócić poprzedni commit, ignorując wszelkie zmiany:

git reset --hard HEAD

Gdzie HEAD jest ostatnim commitem w bieżącej gałęzi

Reverting Kopia robocza do starszego Commita

Aby przywrócić commit starszy niż najnowszy commit:

# Resets index to former commit; replace '56e05fced' with your commit code
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft HEAD@{1}

git commit -m "Revert to 56e05fced"

# Updates working copy to reflect the new commit
git reset --hard

Kredyty idą do podobnego pytania o przepełnienie stosu, przywrócić commit przez SHA hash w Git?.

Najlepszą opcją dla mnie i prawdopodobnie innych jest opcja Git reset:

git reset --hard <commidId> && git clean -f

** Uwaga: * * Jak wspomniano w komentarzach, nie rób tego, jeśli udostępniasz swoją gałąź innym osobom, które mają kopie starych commitów

Również z komentarzy, jeśli chcesz mniej "ballzy" metody można użyć

git clean -i

Zanim odpowiemy, dodajmy trochę tła, wyjaśniając czym jest to HEAD.

First of all what is HEAD?

HEAD jest po prostu odniesieniem do bieżącego commita (latest)w bieżącej gałęzi. W danym momencie może istnieć tylko jedna HEAD (z wyłączeniem git worktree).

Zawartość HEAD jest przechowywana wewnątrz .git/HEAD i zawiera 40 bajtów SHA-1 bieżącego commita.

detached HEAD

Jeśli nie jesteś na najnowszym commit-co oznacza, że HEAD wskazuje na poprzedni commit w historii, który nazywa się detached HEAD.

W wierszu poleceń będzie wyglądać tak - SHA-1 zamiast nazwy gałęzi, ponieważ HEAD nie wskazuje na końcówkę bieżącej gałęzi:

Kilka opcji, jak odzyskać od odłączonej głowy:

git checkout

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits t go back

To wykona nowy oddział wskazując na żądany commit. Polecenie to zostanie pobrane do danego commita.

W tym momencie możesz utworzyć gałąź i rozpocząć pracę od tego momentu:

# Checkout a given commit.
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# Create a new branch forked to the given commit
git checkout -b <branch name>

git reflog

Zawsze możesz użyć reflog. git reflog wyświetli każdą zmianę, która zaktualizowała HEAD, A sprawdzenie żądanego wpisu reflog ustawi HEAD z powrotem do tego commita.

Za każdym razem, gdy głowica zostanie zmodyfikowana, pojawi się nowy wpis w reflog

git reflog
git checkout HEAD@{...}

To przywróci Ci pożądany commit

git reset HEAD --hard <commit_id>

"Przesuń" głowę z powrotem do żądanego commita.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

• Uwaga: (od Git 2.7 ) możesz również użyć git rebase --no-autostash.

Ten schemat ilustruje, które polecenie co robi. Jak widać reset && checkout zmodyfikuj HEAD.

Jeśli Chcesz "zatwierdzić", usunąć ostatnią wiadomość zatwierdzającą i umieścić zmodyfikowane pliki z powrotem w staging, użyj polecenia:

git reset --soft HEAD~1

• --soft wskazuje, że niezakontraktowane pliki powinny być przechowywane jako pliki robocze w przeciwieństwie do --hard, które je odrzuciłyby.
• HEAD~1 jest ostatnim commitem. Jeśli chcesz wycofać 3 commity, możesz użyć HEAD~3. Jeśli chcesz przywrócić konkretny numer wersji, możesz to zrobić również za pomocą skrótu SHA.

To jest niezwykle przydatnym poleceniem w sytuacjach, gdy popełniłeś błąd i chcesz cofnąć ostatni commit.

Źródło: http://nakkaya.com/2009/09/24/git-delete-last-commit/

Możesz to zrobić za pomocą następujących dwóch poleceń:

git reset --hard [previous Commit SHA id here]
git push origin [branch Name] -f

Usunie twój poprzedni commit Git.

Jeśli chcesz zachować swoje zmiany, Możesz również użyć:

git reset --soft [previous Commit SHA id here]

Wtedy zapisze Twoje zmiany.

Próbowałem wielu sposobów, aby przywrócić lokalne zmiany w Git, i wydaje się, że działa to najlepiej, jeśli tylko chcesz przywrócić najnowszy stan commit.

git add . && git checkout master -f

Krótki opis:

• nie utworzy żadnych commitów tak jak robi to git revert.
• nie oderwie ci głowy, jak to robi git checkout <commithashcode>.
• nadpisze wszystkie Twoje lokalne zmiany i usunie wszystkie dodane pliki od ostatniego zatwierdzenia w gałęzi.
• działa tylko z nazwami gałęzi, więc możesz powróci tylko do ostatniego zatwierdzenia w gałęzi w ten sposób.

Znalazłem znacznie wygodniejszy i prosty sposób na osiągnięcie powyższych wyników:

git add . && git reset --hard HEAD

Gdzie HEAD wskazuje na najnowszy commit na bieżącą gałąź.

Jest to ten sam kod, co sugerował boulder_ruby, ale dodałem git add . Przed git reset --hard HEAD, aby usunąć wszystkie nowe pliki utworzone od ostatniego commita, ponieważ jest to to, czego większość ludzi oczekuje podczas powrotu do ostatniego commita.

OK, powrót do poprzedniego commita w Git jest dość prosty...

Odwróć wstecz bez zachowywania zmian:

git reset --hard <commit>

Odwróć wstecz z zachowaniem zmian:

git reset --soft <commit>

Explanation: używając git reset, możesz zresetować do określonego stanu. Często używa się go z Hashem commita, jak widzisz powyżej.

Ale jak widzisz różnica polega na używaniu dwóch flag --soft i --hard, domyślnie git reset używanie flag --soft, ale jest to dobra praktyka zawsze używając flagi, wyjaśniam każdą flagę:

-- soft

Domyślna flaga, jak wyjaśniono, nie musi jej dostarczać, nie zmienia drzewa roboczego, ale dodaje wszystkie zmienione pliki gotowe do zatwierdzenia, więc wracasz do statusu zatwierdzenia, który zmienia się w plikach.

-- hard

Stworzyłem również poniższy obrazek, który może happen in a real life working with Git:

Najlepszy sposób to:

git reset --hard <commidId> && git push --force

Spowoduje to zresetowanie gałęzi do określonego commita, a następnie przesłanie zdalnego serwera z tymi samymi commitami, które masz w local.

Uważaj na znacznik --force, ponieważ usuwa on wszystkie kolejne commity po wybranym commicie bez opcji ich odzyskania.

Zakładając, że mówisz o master i na danej gałęzi (To powiedziawszy, może to być każda działająca gałąź, o którą się martwisz):

# Reset local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

# Reset remote master branch to November 3rd commit ID
git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master

Znalazłem odpowiedź w poście na blogu (teraz już nie istnieje)

Zauważ, że jest to Resetowanie i wymuszanie zmiany na pilocie, tak, że jeśli inni z twojego zespołu już wyciągnęli git, sprawisz im problemy. Niszczysz historię zmian, co jest ważnym powodem, dla którego ludzie używają Gita w pierwszym miejsce.

Lepiej użyć revert (zobacz inne odpowiedzi) niż reset. Jeśli jesteś jednoosobową drużyną, to prawdopodobnie nie ma to znaczenia.

Załóżmy, że masz następujące commity w pliku tekstowym o nazwie ~/commits-to-revert.txt (użyłem git log --pretty=oneline aby je pobrać)

fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
0c27ecfdab3cbb08a448659aa61764ad80533a1b
f85007f35a23a7f29fa14b3b47c8b2ef3803d542
e9ec660ba9c06317888f901e3a5ad833d4963283
6a80768d44ccc2107ce410c4e28c7147b382cd8f
9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
fff2336bf8690fbfb2b4890a96549dc58bf548a5
1f7082f3f52880cb49bc37c40531fc478823b4f5
e9b317d36a9d1db88bd34831a32de327244df36a
f6ea0e7208cf22fba17952fb162a01afb26de806
137a681351037a2204f088a8d8f0db6e1f9179ca

Utwórz skrypt powłoki Bash , aby przywrócić każdy z nich:

#!/bin/bash
cd /path/to/working/copy
for i in `cat ~/commits-to-revert.txt`
do
    git revert $i --no-commit
done

To przywróci wszystko do poprzedniego stanu, łącznie z utworami plików i katalogów oraz usunięciami, zatwierdzi je do swojej gałęzi i zachowasz historię, ale przywrócisz ją do tej samej struktury plików. Dlaczego Git nie ma git revert --to <hash> jest poza mną.

Dodatkowe alternatywy dla rozwiązań Jefromi

Rozwiązania Jefromi są zdecydowanie najlepsze i zdecydowanie powinieneś z nich korzystać. Jednakże, w trosce o kompletność, chciałem również pokazać te inne alternatywne rozwiązania, które mogą być również użyte do odwrócenia commita (w tym sensie, że tworzysz nowy commit, który cofa zmiany w poprzednim commicie , tak jak robi to git revert).

Aby było jasne, te alternatywy nie są najlepszym sposobem na Przywróć zmiany, rozwiązania Jefromi to , ale chcę tylko zaznaczyć, że można również użyć tych innych metod, aby osiągnąć to samo, co git revert.

Alternatywa 1: resety twarde i miękkie

To jest bardzo nieznacznie zmodyfikowana wersja rozwiązania Charlesa Baileya, aby przywrócić commit przez SHA hash w Git?:

# Reset the index to the desired commit
git reset --hard <commit>

# Move the branch pointer back to the previous HEAD
git reset --soft HEAD@{1}

# Commit the changes
git commit -m "Revert to <commit>"

To w zasadzie działa poprzez użycie faktu, że miękkie resety pozostawią stan poprzedniego commita wystawionego w index / staging-area, który można następnie zatwierdzić.

Alternatywa 2: Usuń obecne drzewo i zamień je na nowe

To rozwiązanie pochodzi z rozwiązania svicka do Checkout old commit and make it a new commit :

git rm -r .
git checkout <commit> .
git commit

Podobnie jak alternatywa # 1, odtwarza Stan <commit> w bieżącej kopii roboczej. Najpierw należy wykonać git rm, ponieważ git checkout nie usunie plików dodanych od <commit>.

Oto znacznie prostszy sposób, aby wrócić do poprzedniego commita (i mieć go w stanie niezakontraktowanym, robić z nim co chcesz):

git reset HEAD~1

Więc nie ma potrzeby tworzenia idów commit i tak dalej:)

Istnieje polecenie (nie jest częścią core Git, ale jest w pakiecie Git-extras) specjalnie do przywracania i wystawiania starych commitów:

git back

Na stronie man , może być również używany jako taki:

# Remove the latest three commits
git back 3

Po wszystkich zmianach, po wciśnięciu wszystkich tych poleceń, być może będziesz musiał użyć:

git push -f ...

I nie tylko git push.

Możesz wykonać wszystkie te początkowe kroki samodzielnie i wrócić do repozytorium Git.

1. Pobranie najnowszej wersji repozytorium z Bitbucket za pomocą polecenia git pull --all.

2. Uruchom komendę Git log z -n 4 z twojego terminala. Liczba po -n określa liczbę commitów w dzienniku, począwszy od ostatniego commita w Twojej lokalnej historii.

   $ git log -n 4
   

3. Zresetuj nagłówek historii repozytorium za pomocą git reset --hard HEAD~N gdzie N to liczba commitów, które chcesz cofnąć. W poniższym przykładzie nagłówek zostanie ustawiony z powrotem do ostatniego commita w historii repozytorium:

4. Wypchnij zmianę do repozytorium Git używając git push --force, aby wymusić wypchnięcie zmiany.

Jeśli chcesz, aby repozytorium Git miało poprzedni commit:

git pull --all
git reset --hard HEAD~1
git push --force

Wróć do najnowszego Zatwierdź i Ignoruj wszystkie lokalne zmiany:

git reset --hard HEAD

Wybierz wymagany commit i sprawdź go przez

git show HEAD
git show HEAD~1
git show HEAD~2 

Dopóki nie otrzymasz wymaganego commita. Aby głowa wskazała na to, wykonaj

git reset --hard HEAD~1

Lub git reset --hard HEAD~2 lub cokolwiek.

Jeśli sytuacja jest pilna , i chcesz po prostu zrobić to, o co pytający zapytał w szybki i brudny sposób, zakładając, że twój projekt znajduje się w katalogu o nazwie, na przykład, "mój projekt":

Szybkie i brudne: w zależności od okoliczności, szybkie i brudne mogą być w rzeczywistości bardzo dobre. Moje rozwiązanie polega na tym, że NIE zastępuję nieodwracalnie pliki znajdujące się w katalogu roboczym plikami wyciągniętymi/wydobywanymi z głębi repozytorium git czai się pod twoim .Git / directory używa diabelsko sprytnych i diabolicznie potężnych komend git, których jest wiele. Nie musisz nurkować GŁĘBINOWO, aby odzyskać to, co może wydawać się katastrofalne, a próba zrobienia tego bez wystarczającej wiedzy specjalistycznej może okazać się śmiertelna.

1. Skopiuj cały katalog i nazwij go czymś innym, jak "mój projekt-Kopia". Zakładając, że Twoje repozytorium git ("repo") znajduje się pod "my projekt "katalog (domyślne miejsce dla nich, pod katalog o nazwie".git"), będziesz teraz kopiował zarówno pliki robocze, jak i pliki repo.

2. Zrób to w katalogu "mój projekt":

   .../my project $ git reset --hard [first-4-letters&numbers-of-commit's-SHA]
   

To zwróci stan repo w sekcji " Mój projekt "do stanu, jaki był w momencie tworzenia tego commita ("commit" oznacza migawkę plików roboczych). Wszystkie commity od tego czasu zostaną utracone na zawsze w ramach "mojego projektu", ale... nadal będą zaprezentuj w repo pod "mój projekt-Kopia", ponieważ skopiowałeś wszystkie te pliki - w tym te pod .../.git/

Następnie masz dwie wersje w systemie... możesz przejrzeć, skopiować lub zmodyfikować interesujące Cię pliki lub cokolwiek innego z poprzedniego commita. Możesz całkowicie odrzucić pliki w sekcji "Mój projekt-Kopia", jeśli zdecydowałeś, że nowa praca, ponieważ przywrócony commit zmierza donikąd...

Oczywistą rzeczą, jeśli chcesz kontynuować stan Projekt bez odrzucenia pracy, ponieważ ten pobrany commit ma ponownie zmienić nazwę katalogu: usunąć projekt zawierający pobrany commit (lub nadać mu tymczasową nazwę) I zmienić nazwę katalogu "mój projekt - Kopia" z powrotem na "mój projekt". To może spróbuj zrozumieć niektóre z innych odpowiedzi tutaj, i prawdopodobnie zrobić kolejny commit dość szybko.

Szczególnie jeśli, na przykład, jest to desperacka sytuacja i jesteś nowicjuszem z Git!

PS: jeszcze jedna myśl: to jest (teraz) całkiem proste, aby utrzymać repo Git w katalogu innym niż ten z plikami roboczymi. Oznaczałoby to, że nie miałbyś aby skopiować całe repozytorium Git używając powyższego rozwiązania quick & dirty. Zobacz odpowiedź użytkownika Frytkownica --separate-git-dir tutaj . bądź jednak ostrzeżony : Jeśli masz repozytorium "oddzielny katalog", którego nie kopiujesz, a wykonujesz twardy reset, wszystkie wersje po zatwierdzeniu resetu zostaną utracone na zawsze, chyba że masz, jak absolutnie powinieneś, regularnie wykonuj kopię zapasową swojego repozytorium, najlepiej w chmurze (np. Dysk Google) między innymi.

W tym temacie kolejnym krokiem jest otwarcie konta (oczywiście za darmo) na Githubie lub (moim zdaniem lepiej) GitLab. Następnie możesz regularnie wykonywać polecenie git push, aby uaktualnić repo w chmurze "prawidłowo". Ale znowu, mówienie o tym może być zbyt wiele za wcześnie.

Jest to jeszcze jeden sposób, aby bezpośrednio zresetować do ostatniego commita

git stash
git stash clear

Bezpośrednio usuwa wszystkie zmiany, które zostały wprowadzone od ostatniego commita.

PS: ma mały problem; usuwa również wszystkie ostatnio przechowywane zmiany skrytki. Co chyba w większości przypadków nie powinno mieć znaczenia.

Aby całkowicie oczyścić katalog kodera z przypadkowych zmian, użyliśmy:

git add -A .
git reset --hard HEAD

Po Prostu git reset --hard HEAD pozbędzie się modyfikacji, ale nie pozbędzie się "nowych" plików. W ich przypadku przypadkowo przeciągnęli ważny folder w dowolne miejsce, a wszystkie te pliki były traktowane przez Git jako nowe, więc reset --hard tego nie naprawił. Uruchamiając git add -A . wcześniej, wyraźnie wyśledził je wszystkie za pomocą Gita, aby zostały wymazane przez reset.

Aby zachować zmiany z poprzedniego commita do HEAD i przenieść je do poprzedniego commita, wykonaj:

git reset <SHA>

Jeśli zmiany nie są wymagane od poprzedniego commitu do HEAD i po prostu odrzuć wszystkie zmiany, wykonaj:

git reset --hard <SHA>

Wierzę, że niektórzy ludzie mogą przyjść na to pytanie, chcąc wiedzieć, jak cofnąć wprowadzone zmiany w swoim master - czyli wyrzucić wszystko i wrócić do origin/master, w takim przypadku zrób to:

git reset --hard origin/master

Https://superuser.com/questions/273172/how-to-reset-master-to-origin-master

Revert jest poleceniem do cofnięcia commitów.

git revert <commit1> <commit2> 

próbka:

git revert 2h3h23233

git revert HEAD~1..HEAD

A następnie zrobić git push

Uwaga! to polecenie może spowodować utratę historii zatwierdzeń, jeśli użytkownik błędnie wpisał błędny zatwierdzanie. Zawsze mieć PL dodatkową kopię zapasową Twojego git niektóre gdzie indziej na wszelki wypadek, jeśli popełniasz błędy, niż jesteś nieco bezpieczniejszy. :)

Miałem podobny problem i chciałem wrócić do wcześniejszego commita. W moim przypadku nie byłem zainteresowany utrzymaniem nowszego commita, dlatego użyłem Hard.

Tak to zrobiłem:

git reset --hard CommitId && git clean -f

To powróci na lokalnym repozytorium, a tutaj po użyciu {[3] } zaktualizuje zdalne repozytorium.

git push -f

Spróbuj zresetować do żądanego commita-

git reset <COMMIT_ID>

(aby sprawdzić COMMIT_ID użyj git log)

Spowoduje to zresetowanie wszystkich zmienionych plików do stanu nie dodanego.

Teraz możesz checkout wszystkie Nie dodane pliki przez

git checkout .

Sprawdź git log, Aby zweryfikować swoje zmiany.

UPDATE

git update-ref -d HEAD

Ponieważ twoje commity są wypychane zdalnie, musisz je usunąć. Załóżmy, że Twoja gałąź jest rozwijana i jest przesunięta nad origin .

Najpierw musisz usunąć develop z origin :

git push origin :develop (note the colon)

Następnie musisz dostać się do statusu, który chcesz, pozwól mi założyć, że hash commit to EFGHIJK:

git reset --hard EFGHIJK

Na koniec wciśnij rozwiń Jeszcze raz:

git push origin develop

Dla cofnięcia (lub cofnięcia):

1. git revert --no-commit "commit-code-to-remove" HEAD
(e.g. git revert --no-commit d57a39d HEAD)
2. git commit
3. git push

Wypróbuj powyższe dwa kroki, a jeśli okaże się, że to jest to, czego chcesz, to git push.

Jeśli znajdziesz coś nie tak, zrób:

git revert --abort

Jeśli chcesz poprawić jakiś błąd w ostatnim zatwierdzeniu, dobrą alternatywą byłoby użycie git commit --amend. Jeśli ostatni commit nie jest wskazywany przez żadne odniesienie, zrobi to sztuczkę, ponieważ tworzy commit z tym samym rodzicem co ostatni commit. Jeśli nie ma odniesienia do ostatniego commita, zostanie on po prostu odrzucony i ten commit będzie ostatnim commitem. Jest to dobry sposób na poprawianie commitów bez odwracania commitów. Ma jednak swoje ograniczenia.