Zakładając, że twój lokalny mistrz nie był przed origin/master, powinieneś być w stanie zrobić

git reset --hard origin/master

Wtedy Twoja lokalna gałąź master powinna wyglądać identycznie jak origin/master.

Zobacz Rozdział 4 w Git book i oryginalny post Linusa Torvaldsa .

Aby cofnąć połączenie , które zostało już popchnięte :

git revert -m 1 commit_hash

Upewnij się, że przywrócisz przywracanie, jeśli ponownie zatwierdzisz gałąź, tak jak powiedział Linus.

Dziwne, że brakowało najprostszego polecenia. Większość odpowiedzi działa, ale cofając połączenie, które właśnie zrobiłeś, jest to łatwy i bezpieczny sposób :

git reset --merge ORIG_HEAD

Ref ORIG_HEAD wskaże oryginalny commit sprzed połączenia.

(Opcja --merge nie ma nic wspólnego z połączeniem. Jest tak samo jak git reset --hard ORIG_HEAD, ale bezpieczniej, ponieważ nie dotyka niewymaganych zmian.)

W nowszych wersjach Git, jeśli nie dokonałeś jeszcze połączenia i masz konflikt scalania , możesz po prostu zrobić:

git merge --abort

From man git merge:

[This] można uruchomić tylko po tym, jak połączenie doprowadziło do konfliktów. git merge --abort przerywa proces scalania i próbuje zrekonstruować stan przed scaleniem.

Powinieneś zresetować poprzedni commit. Powinno działać:

git reset --hard HEAD^

Lub nawet HEAD^^ aby cofnąć ten commit. Zawsze możesz podać pełne odniesienie do SHA, jeśli nie jesteś pewien, ile kroków wstecz powinieneś podjąć.

W przypadku, gdy masz problemy i twoja gałąź master nie miała żadnych lokalnych zmian, możesz zresetować do origin/master.

Ostatnio używam git reflog do pomocy w tym. To działa tylko wtedy, gdy połączenie właśnie się stało i było na Twojej maszynie.

git reflog może zwrócić coś w stylu:

fbb0c0f HEAD@{0}: commit (merge): Merge branch 'master' into my-branch
43b6032 HEAD@{1}: checkout: moving from master to my-branch
e3753a7 HEAD@{2}: rebase finished: returning to refs/heads/master
e3753a7 HEAD@{3}: pull --rebase: checkout e3753a71d92b032034dcb299d2df2edc09b5830e
b41ea52 HEAD@{4}: reset: moving to HEAD^
8400a0f HEAD@{5}: rebase: aborting

Pierwsza linia wskazuje, że nastąpiło połączenie. Druga linia to czas przed połączeniem. Po prostu zmuszam tę gałąź do śledzenia przed połączeniem i kontynuowania.

Z nowoczesnym Gitem możesz:

git merge --abort

Starsza składnia:

git reset --merge

Old-school:

git reset --hard

Ale właściwie, warto zauważyć, że git merge --abort jest tylko równoważne git reset --merge biorąc pod uwagę, że MERGE_HEAD jest obecny. Można to odczytać w Komendzie Git help for merge.

git merge --abort is equivalent to git reset --merge when MERGE_HEAD is present.

Po nieudanym połączeniu, gdy nie ma MERGE_HEAD, nieudane połączenie można cofnąć za pomocą git reset --merge, ale niekoniecznie za pomocą git merge --abort, są więc nie tylko starą i nową składnią dla tego samego rzecz .

Osobiście uważam git reset --merge o wiele bardziej wydajne i przydatne w codziennej pracy, więc to jest ten, z którego zawsze korzystam.

Dobra, odpowiedzi od innych ludzi były bliskie, ale nie zadziałały. Oto co zrobiłem.

git reset --hard HEAD^
git status

...dał mi następujący status.

# On branch master
# Your branch and 'origin/master' have diverged,
# and have 3 and 3 different commit(s) each, respectively.

Musiałem jeszcze kilka razy wpisać tę samą komendę git reset. Za każdym razem, gdy to robiłem, wiadomość zmieniała się o jeden, jak widać poniżej.

> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch and 'origin/master' have diverged,
# and have 3 and 3 different commit(s) each, respectively.
> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch and 'origin/master' have diverged,
# and have 2 and 3 different commit(s) each, respectively.
> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch and 'origin/master' have diverged,
# and have 1 and 3 different commit(s) each, respectively.
> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch is behind 'origin/master' by 3 commits, and can be fast-forwarded.

W tym momencie zobaczyłem, że wiadomość o statusie się zmieniła, więc spróbowałem zrobić git pull i wydawało się, że działa:

> git pull
Updating 2df6af4..12bbd2f
Fast forward
 app/views/truncated |    9 ++++++---
 app/views/truncated |   13 +++++++++++++
 app/views/truncated |    2 +-
 3 files changed, 20 insertions(+), 4 deletions(-)
> git status
# On branch master

So long story short, my komendy sprowadzały się do tego:

git reset --hard HEAD^
git reset --hard HEAD^
git reset --hard HEAD^
git reset --hard HEAD^
git pull

Musisz zmienić głowę, oczywiście nie Twoją, ale git HEAD....

Więc zanim odpowiemy, dodajmy trochę tła, wyjaśniając, co to jest 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 z bieżący commit.

detached HEAD

Jeśli nie jesteś na ostatnim commicie - 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 w 1999 roku, w 1999 roku, po raz pierwszy w historii, został wybrany do Izby Gmin.]}

---

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 nową gałąź 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 i wyświetli żądany reflog wpis 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 --hard <commit_id>

"Przenieś" 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 jako cóż.

git revert <sha-1>

"Cofnij" dany commit lub zakres zmian.
Polecenie reset "cofnie" wszelkie zmiany wprowadzone w danym zatwierdzeniu.
Nowy commit z łatką undo zostanie zatwierdzony, podczas gdy oryginalny commit pozostanie również w historii.

# add new commit with the undo of the original one.
# the <sha-1> can be any commit(s) or commit range
git revert <sha-1>

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

Możesz użyć git reflog, aby znaleźć poprzedni zakup. Czasami jest to dobry stan, do którego chcesz wrócić.

Konkretnie,

$ git reflog
$ git reset --hard HEAD@{0}

Jeśli jesteś w trakcie scalania, zawsze możesz to przerwać git merge --abort

Udało mi się rozwiązać ten problem za pomocą jednego polecenia, które nie wymaga wyszukiwania identyfikatora zmian.

git reset --hard remotes/origin/HEAD

Przyjęta odpowiedź nie zadziałała dla mnie, ale polecenie to osiągnęło wyniki, których szukałem.

Można to zrobić na wiele sposobów.

1) Abort Merge

Jeśli jesteś pomiędzy złym scaleniem (błędnie wykonanym z niewłaściwą gałęzią) i chcesz uniknąć scalenia, aby wrócić do gałęzi ostatnio jak poniżej:

git merge --abort

2) Resetuj głowicę do zdalnej gałęzi

Jeśli pracujesz z zdalnej gałęzi develop, możesz zresetować głowę do ostatniego commita na zdalnej gałęzi jak poniżej:

git reset --hard origin/develop

3) Usuń bieżącą gałąź i Kasuj ponownie ze zdalnego repozytorium

Biorąc pod uwagę, że pracujesz nad rozwijaną gałęzią w lokalnym repo, która synchronizuje się ze zdalną / rozwijaną gałęzią, możesz zrobić to jak poniżej:

git checkout master 
##to delete one branch, you need to be on another branch, otherwise you will fall with the branch :) 

git branch -D develop
git checkout -b develop origin/develop

Jeśli jeszcze go nie zatwierdziłeś, możesz użyć tylko

$ git checkout -f

Spowoduje cofnięcie połączenia (i wszystkiego, co zrobiłeś).

Zająłem się tym pytaniem również szukając powrotu do match origin(tzn. brak commitów przed origin). Szukając dalej, okazało się, że istnieje reset polecenie dokładnie to:

git reset --hard @{u}

Uwaga: @{u} jest skrótem od origin/master. (I, oczywiście, potrzebujesz tego zdalnego repozytorium, aby to działało.)

Najprostszą odpowiedzią jest odpowiedź odinho-Velmont

First do git reset --merge ORIG_HEAD

Dla tych, którzy chcą się zresetować po wypchnięciu zmian, zrób to (Ponieważ jest to pierwszy post widziany dla wszystkich pytań Git reset merge)

git push origin HEAD --force

Spowoduje to zresetowanie w taki sposób, że nie otrzymasz ponownie scalonych zmian po pociągnięciu.

Możesz użyć tylko dwóch poleceń, aby przywrócić scalenie lub restart przez określony commit:

1. git reset --hard commitHash (powinieneś użyć commita, który chcesz zrestartować, np. 44a587491e32eafa1638aca7738)
2. git push origin HEAD --force (wysyłanie nowej lokalnej gałęzi master do origin/master)

Tylko dla dodatkowej opcji do obejrzenia, głównie podążałem za opisanym tutaj modelem rozgałęzienia: http://nvie.com/posts/a-successful-git-branching-model / i jako takie zostały połączone z --no-ff (nie fast forward) Zwykle.

Właśnie przeczytałem tę stronę, ponieważ przypadkowo połączyłem gałąź testową zamiast mojej gałęzi release z master do wdrożenia(website, master jest tym, co jest live). Gałąź testing ma dwie inne gałęzie połączone z nią i wynosi około sześciu commitów.

Więc aby cofnąć cały commit potrzebowałem tylko jednego {[1] } i to cofnęło całe połączenie. Ponieważ połączenia nie były szybko przekazywane, połączenie było blokiem, a jeden krok wstecz to "branch not merged".

Jeśli Twoje scalenie i odpowiednie commity nie zostały jeszcze wypchnięte, zawsze możesz przełączyć się na inną gałąź, usunąć oryginalną i utworzyć ją ponownie.

Na przykład przypadkowo połączyłem gałąź develop w master i chciałem to cofnąć. Korzystając z następujących kroków:

git checkout develop
git branch -D master
git branch -t master origin/master

Jeśli gałęzie są murowane i nie są popychane. Następnie poniższe polecenie Git reset spowoduje cofnięcie połączenia: git reset --merge ORIG_HEAD

Jeśli chcesz rozwiązanie wiersza poleceń, proponuję po prostu wybrać odpowiedź MBO.

Jeśli jesteś nowicjuszem, może spodobać ci się podejście graficzne:

1. Kick off gitk (z linii poleceń, lub kliknij prawym przyciskiem myszy w przeglądarce plików, jeśli tak masz)
2. możesz łatwo zauważyć commit merge - pierwszy węzeł od góry z dwoma rodzicami
3. podążaj za linkiem do pierwszego / lewego rodzica (tego na bieżącej gałęzi przed scaleniem, Zwykle dla mnie czerwonego)
4. na wybierz commit, kliknij prawym przyciskiem myszy "Resetuj gałąź tutaj", wybierz twardy reset tam

Strategia: Stwórz nową gałąź, z której wszystko było dobre.

Uzasadnienie: przywrócenie połączenia jest trudne. Istnieje zbyt wiele rozwiązań, w zależności od wielu czynników, takich jak to, czy zatwierdziłeś lub popchnąłeś scalenie lub czy pojawiły się nowe zmiany od czasu scalenia. Ponadto nadal musisz mieć relatywnie głębokie zrozumienie Gita, aby dostosować te rozwiązania do twojego przypadku. Jeśli ślepo postępujesz zgodnie z instrukcjami, możesz skończyć z "pustym połączeniem", w którym nic zostanie scalony, a kolejne próby scalenia sprawią, że Git powie Ci "już aktualne".

Rozwiązanie:

Załóżmy, że chcesz połączyć dev w feature-1.

1. Znajdź wersję, którą chcesz otrzymać scalenie:

   git log --oneline feature-1
   a1b2c3d4 Merge branch 'dev' into 'feature-1' <-- the merge you want to undo
   e5f6g7h8 Fix NPE in the Zero Point Module <-- the one before the merge, you probably want this one
   

2. Sprawdź (cofnij się w czasie):

   git checkout e5f6g7h8
   

3. Utwórz nową gałąź i sprawdź ją:

   git checkout -b feature-1
   

Teraz możesz ponownie uruchomić swój merge:

1. Merge: git merge dev

2. Napraw swoje konflikty scalania.

3. Commit: git commit

4. Gdy będziesz zadowolony z wyników, usuń starą gałąź: git branch --delete feature-1

Po prostu utwórz nową gałąź, a następnie wybierz pożądane commity do niej.

Jego wygaszacz i prostsze, a następnie resetuje opisane w wielu odpowiedziach powyżej

Myślę, że możesz zrobić git rebase -i [hash] [branch_name] gdzie [hash] jest identyfikującym hash dla tego, jak daleko wstecz chcesz przewijać plus jeden (lub jak wiele commitów wstecz chcesz przejść), a następnie usunąć linie dla commitów w edytorze, których już nie chcesz. Zapisz plik. Wyjście. Módl się. I powinno być od nowa. Być może będziesz musiał zrobić git reset --hard, ale w tym momencie powinno być dobrze. Możesz również użyć tego do wyciągnięcia określonych commitów ze stosu, jeśli nie chcesz zachować ich w swojej historii, ale to może pozostaw swoje repozytorium w stanie, którego prawdopodobnie nie chcesz.

If you committed the merge:

git reset HEAD~1
# Make sure what you are reverting is in fact the merge files
git add .
git reset --hard

1. Po pierwsze, upewnij się, że popełniłeś wszystko.

2. Następnie zresetuj repozytorium do poprzedniego stanu roboczego:

   $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36
   

   Lub za pomocą --hard (spowoduje to usunięcie wszystkich lokalnych, niezaangażowanych zmian!):

   $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36 --hard
   

   Użyj hasha, który był tam przed nieprawidłowo połączonym commitem.

3. Sprawdź, które commity chcesz ponownie zatwierdzić na górze poprzedniej poprawnej wersji:

   $ git log 4c3e23f529b581c3cbe95350e84e66e3cb05704f
   
   commit 4c3e23f529b581c3cbe95350e84e66e3cb05704f
   
   ...
   
   commit 16b373a96b0a353f7454b141f7aa6f548c979d0a
   
   ...
   

4. Zastosuj swoje prawo commity na górze prawej wersji repozytorium przez:

   • Używając cherry-pick (zmiany wprowadzone przez niektóre istniejące commity)

         git cherry-pick ec59ab844cf504e462f011c8cc7e5667ebb2e9c7
     

   • Lub wybierając zakres commitów przez:

     • Najpierw sprawdzenie poprawnych zmian przed ich połączeniem:

       git diff 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
       

     • Najpierw sprawdzenie poprawnych zmian przed ich połączeniem:

       git cherry-pick 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
       

       Gdzie jest to zakres poprawnych commitów, które popełniłeś (z wyłączeniem nieprawidłowo popełnionego merge).

1. git stash

2. git branch -d the_local_branch

3. git checkout -t <name of remote>

4. git stash apply

Jeśli zauważysz, że musisz powrócić natychmiast po połączeniu i nie zrobiłeś nic więcej po próbie połączenia, możesz po prostu wydać to polecenie: git reset --hard HEAD@{1}.

Zasadniczo, Twoje połączenie sha będzie wskazywało na HEAD@{0}, jeśli nic innego nie zostało popełnione po połączeniu, a więc HEAD@{1} będzie poprzednim punktem przed połączeniem.

Najprostsza z najprostszych szans, znacznie prostsza niż cokolwiek tu powiedziane:

Usuń lokalną gałąź (lokalną, nie zdalną) i pociągnij ją ponownie. W ten sposób cofniesz zmiany w gałęzi master i każdy będzie dotknięty zmianą, której nie chcesz wypychać. Zacznij od nowa.