All'interno del mio ramo principale, ho fatto un git merge some-other-branchlocale, ma non ho mai spinto le modifiche al master di origine. Non intendevo unirmi, quindi mi piacerebbe annullarlo. Quando facevo un git statusafter my merge, stavo ricevendo questo messaggio:

# On branch master
# Your branch is ahead of 'origin/master' by 4 commits.

Sulla base di alcune istruzioni che ho trovato , ho provato a correre

git revert HEAD -m 1

ma ora ricevo questo messaggio con git status:

# On branch master
# Your branch is ahead of 'origin/master' by 5 commits.

Non voglio che la mia filiale sia in vantaggio per un numero qualsiasi di commit. Come posso tornare a quel punto?

Con git reflogverifica quale commit è uno prima della fusione ( git reflogsarà un'opzione migliore di git log). Quindi è possibile ripristinarlo utilizzando:

git reset --hard commit_sha

C'è anche un altro modo:

git reset --hard HEAD~1

Ti restituirà 1 commit.

Tenere presente che tutti i file modificati e non compressi / non compressi verranno ripristinati al loro stato non modificato . Per tenerli nascosti o modificare le modifiche o vedere l' --mergeopzione di seguito.

Come suggerito da @Velmont di seguito nella sua risposta, in questo caso diretto usando:

git reset --hard ORIG_HEAD

potrebbe produrre risultati migliori, poiché dovrebbe preservare le modifiche. ORIG_HEADindicherà un commit direttamente prima che si verifichi l'unione, quindi non devi cercarlo da solo.

Un ulteriore suggerimento è utilizzare l' --mergeopzione invece di --hardnon ripristinare inutilmente i file:

git reset --merge ORIG_HEAD

--merge

Reimposta l'indice e aggiorna i file dell'albero di lavoro che sono diversi tra <commit> e HEAD, ma mantiene quelli che sono diversi tra l'indice e l'albero di lavoro (ovvero che hanno modifiche che non sono state aggiunte).

Supponendo che il tuo master locale non fosse in anticipo rispetto a origin / master, dovresti essere in grado di farlo

git reset --hard origin/master

Quindi la tua masterfiliale locale dovrebbe apparire identica a origin/master.

Vedi il capitolo 4 del libro Git e il post originale di Linus Torvalds .

Per annullare una fusione già spinta :

git revert -m 1 commit_hash

Assicurati di ripristinare il ripristino se stai commettendo di nuovo il ramo, come ha detto Linus.

È strano che mancasse il comando più semplice. La maggior parte delle risposte funziona, ma annullando l'unione che hai appena fatto, questo è il modo semplice e sicuro :

git reset --merge ORIG_HEAD

L'arbitro ORIG_HEADpunterà al commit originale prima della fusione.

(L' --mergeopzione non ha nulla a che fare con l'unione. È proprio come git reset --hard ORIG_HEAD, ma più sicura poiché non tocca le modifiche non confermate.)

Con le versioni Git più recenti, se non hai ancora eseguito il commit dell'unione e hai un conflitto di unione , puoi semplicemente fare:

git merge --abort

Da man git merge:

[Questo] può essere eseguito solo dopo che l'unione ha provocato conflitti. git merge --abortinterromperà il processo di unione e proverà a ricostruire lo stato di pre-unione.

È necessario ripristinare il commit precedente. Questo dovrebbe funzionare:

git reset --hard HEAD^

O anche HEAD^^per ripristinare quel commit di ripristino. Puoi sempre fornire un riferimento SHA completo se non sei sicuro di quanti passi indietro dovresti fare.

Nel caso in cui si riscontrino problemi e il ramo master non abbia subito modifiche locali, è possibile ripristinare origin/master.

Ultimamente, ho usato git reflogper aiutare con questo. Questo funziona principalmente solo se l'unione è avvenuta SOLO, ed era sulla tua macchina.

git reflog potrebbe restituire qualcosa del tipo:

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

La prima riga indica che si è verificata un'unione. La seconda riga è il tempo prima della mia unione. Devo semplicemente git reset --hard 43b6032forzare questo ramo a rintracciare prima della fusione e proseguire.

Con Git moderno puoi:

git merge --abort

Sintassi precedente:

git reset --merge

Vecchia scuola:

git reset --hard

Ma in realtà, vale la pena notare che git merge --abortè solo equivalente a git reset --mergedato che MERGE_HEADè presente. Questo può essere letto nella guida di Git per il comando di unione.

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

Dopo un'unione fallita, quando non c'è MERGE_HEAD, l'unione fallita può essere annullata git reset --merge, ma non necessariamente con git merge --abort, quindi non sono solo vecchia e nuova sintassi per la stessa cosa .

Personalmente trovo git reset --mergemolto più potente e utile nel lavoro quotidiano, quindi è quello che uso sempre.

Ok, le risposte che altre persone qui mi hanno dato sono state vicine, ma non ha funzionato. Ecco cosa ho fatto.

Facendo questo...

git reset --hard HEAD^
git status

... mi ha dato il seguente status.

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

Ho quindi dovuto digitare lo stesso git resetcomando più volte. Ogni volta che l'ho fatto, il messaggio è cambiato di uno come puoi vedere di seguito.

> 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.

A questo punto, ho visto il messaggio di stato cambiato, quindi ho provato a fare un git pull, e sembrava funzionare:

> 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

Per farla breve, i miei comandi sono arrivati ​​a questo:

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

È possibile utilizzare git reflogper trovare il checkout precedente. A volte è un buon stato in cui vuoi tornare.

concretamente,

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

Se sei nel mezzo della fusione, puoi sempre interromperlo git merge --abort

Sono stato in grado di risolvere questo problema con un singolo comando che non comporta la ricerca di un ID commit.

git reset --hard remotes/origin/HEAD

La risposta accettata non ha funzionato per me, ma questo comando ha ottenuto i risultati che stavo cercando.

Se non l'hai ancora fatto, puoi solo usare

$ git checkout -f

Annullerà l'unione (e tutto ciò che hai fatto).

Sono arrivato a questa domanda anche cercando di ripristinare la corrispondenza dell'origine (ovvero, NO si impegna prima dell'origine). Effettuando ulteriori ricerche, è emerso che esiste resetesattamente un comando per questo:

git reset --hard @{u}

Nota: @{u}è una scorciatoia per origin/master. (E, naturalmente, hai bisogno di quel repository remoto per farlo funzionare.)

Devi cambiare la TESTA, non la tua ovviamente, ma vai a TESTA ....

Quindi, prima di rispondere, aggiungiamo alcuni retroscena, spiegando di cosa si tratta HEAD.

First of all what is HEAD?

HEADè semplicemente un riferimento al commit corrente (più recente) sul ramo corrente.
Può essercene solo uno HEADin qualsiasi momento. (escluso git worktree)

Il contenuto di HEADè memorizzato all'interno .git/HEADe contiene i 40 byte SHA-1 del commit corrente.

detached HEAD

Se non si esegue l'ultimo commit, il che significa che HEADindica un commit precedente nella cronologia che viene chiamato detached HEAD.

Sulla riga di comando, sarà simile al seguente: SHA-1 invece del nome del ramo poiché HEADnon punta alla punta del ramo corrente

Alcune opzioni su come recuperare da una HEAD staccata:

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

Questo verificherà il nuovo ramo che punta al commit desiderato.
Questo comando eseguirà il checkout per un determinato commit.
A questo punto, puoi creare un ramo e iniziare a lavorare da questo punto in poi.

# 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

Puoi sempre usare refloganche quello.
git reflogvisualizzerà qualsiasi modifica che ha aggiornato il HEADe il checkout della voce di reflog desiderata HEADriporterà questo commit.

Ogni volta che HEAD viene modificato, ci sarà una nuova voce in reflog

git reflog
git checkout HEAD@{...}

Questo ti riporterà al commit desiderato

git reset --hard <commit_id>

"Sposta" HEAD indietro al commit desiderato.

# 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.

• Nota: ( da Git 2.7 )
  puoi anche usare git rebase --no-autostashanche questo.

git revert <sha-1>

"Annulla" l'intervallo di commit o commit specificato.
Il comando reset "annulla" tutte le modifiche apportate nel commit dato.
Verrà eseguito il commit di un nuovo commit con la patch di annullamento mentre il commit originale rimarrà anche nella cronologia.

# 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>

Questo schema illustra quale comando fa cosa.
Come puoi vedere, reset && checkoutmodifica il HEAD.

La risposta più semplice è quella data da Odinho - Velmont

Prima di tutto git reset --merge ORIG_HEAD

Per coloro che desiderano reimpostare dopo che le modifiche sono state inviate, esegui questa operazione (poiché questo è il primo post visualizzato per qualsiasi domanda di merge git reset)

git push origin HEAD --force

Ciò verrà reimpostato in modo tale da non riavere indietro le modifiche unite dopo il pull.

Solo per un'opzione in più da guardare, ho principalmente seguito il modello di ramificazione descritto qui: http://nvie.com/posts/a-successful-git-branching-model/ e come tale mi sono unito--no-ff (no avanzamento veloce) di solito.

Ho appena letto questa pagina poiché ho accidentalmente unito un ramo di prova anziché il mio ramo di rilascio con master per la distribuzione (sito Web, master è ciò che è attivo). La filiale di test ha due altre filiali unite ad essa e ammonta a circa sei commit.

Quindi per ripristinare l'intero commit ne avevo solo bisogno git reset --hard HEAD^e ha ripristinato l'intera unione. Poiché le fusioni non sono state inoltrate rapidamente, la fusione è stata un blocco e un passo indietro è "ramo non unito".

È possibile utilizzare solo due comandi per ripristinare un'unione o riavviare con un commit specifico:

1. git reset --hard commitHash (è necessario utilizzare il commit che si desidera riavviare, ad es. 44a587491e32eafa1638aca7738)
2. git push origin HEAD --force (Invio del nuovo ramo principale locale a origine / principale)

Buona fortuna e vai avanti!

Può essere fatto in diversi modi.

1) Annulla unione

Se sei nel mezzo di una cattiva unione (erroneamente eseguita con un ramo sbagliato) e volevi evitare l'unione per tornare al ramo più recente come di seguito:

git merge --abort

2) Ripristinare HEAD sul ramo remoto

Se stai lavorando dal ramo di sviluppo remoto, puoi ripristinare HEAD all'ultimo commit sul ramo remoto come di seguito:

git reset --hard origin/develop

3) Elimina il ramo corrente ed esegui nuovamente il checkout dal repository remoto

Considerando che stai lavorando allo sviluppo del ramo nel repository locale, che si sincronizza con il ramo remoto / sviluppo, puoi fare come di seguito:

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

Se la tua unione e i relativi commit non sono ancora stati inviati, puoi sempre passare a un altro ramo, eliminare quello originale e ricrearlo.

Ad esempio, ho accidentalmente unito un ramo di sviluppo in master e volevo annullarlo. Utilizzando i seguenti passaggi:

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

Ecco! Il master è allo stesso livello dell'origine e il tuo stato di fusione errata viene cancellato.

Se vuoi una soluzione da riga di comando, ti suggerisco di seguire la risposta di MBO.

Se sei un principiante, potrebbe piacere l'approccio grafico:

1. Inizia gitk(dalla riga di comando o fai clic con il pulsante destro del mouse nel browser dei file se lo hai)
2. Puoi facilmente individuare il commit di unione lì - il primo nodo dall'alto con due genitori
3. Segui il link al primo / sinistra genitore (quello sul tuo ramo corrente prima dell'unione, di solito rosso per me)
4. Sul commit selezionato, fai clic con il pulsante destro del mouse su "Ripristina ramo qui", seleziona lì il ripristino hardware

Strategia: creare un nuovo ramo da cui tutto andava bene.

Motivazione: Ripristinare un'unione è difficile. Esistono troppe soluzioni, a seconda di molti fattori, ad esempio se hai eseguito il commit o il push della tua unione o se ci sono stati nuovi commit dalla tua unione. Inoltre, devi ancora avere una conoscenza relativamente profonda di git per adattare queste soluzioni al tuo caso. Se segui ciecamente alcune istruzioni, puoi finire con una "fusione vuota" in cui nulla verrà unito e ulteriori tentativi di fusione faranno in modo che Git ti dica "Già aggiornato".

Soluzione:

Diciamo che si desidera unire devin feature-1.

1. Trova la revisione che desideri ricevere l'unione:

   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. Dai un'occhiata (torna indietro nel tempo):

   git checkout e5f6g7h8
   

3. Crea un nuovo ramo da lì e provalo:

   git checkout -b feature-1
   

Ora puoi riavviare l'unione:

1. Merge: git merge dev

2. Risolvi i conflitti di unione.

3. Commettere: git commit

4. Quando sei soddisfatto dei risultati, elimina il vecchio ramo: git branch --delete feature-1

Basta creare un nuovo ramo, quindi selezionare la ciliegina desiderata.

Il suo risparmio e più semplice ripristina quindi descritto in molte risposte sopra

Penso che tu possa fare git rebase -i [hash] [branch_name] dov'è [hash]l'hash identificativo per quanto lontano indietro vuoi riavvolgere più uno (o comunque molti commit indietro che vuoi andare) e quindi eliminare le righe per i commit nell'editor che non vuoi più . Salva il file. Uscita. Pregare. E dovrebbe essere riavvolto. Potrebbe essere necessario fare un git reset --hard, ma dovrebbe essere buono a questo punto. Puoi anche usarlo per estrarre specifici commit da uno stack, se non vuoi tenerli nella tua cronologia, ma ciò può lasciare il tuo repository in uno stato che probabilmente non vuoi.

Se hai eseguito l'unione:

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

1. Innanzitutto, assicurati di aver commesso tutto.

2. Quindi ripristinare il repository allo stato di lavoro precedente:

   $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36
   

   o usando --hard( questo rimuoverà tutte le modifiche locali e non impegnate! ):

   $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36 --hard
   

   Usa l'hash presente prima del commit erroneamente unito.

3. Controlla quali commit desideri ripetere il commit nella parte superiore della versione corretta precedente:

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

4. Applica i tuoi commit giusti nella parte superiore della versione corretta del tuo repository:

   • Usando cherry-pick (le modifiche introdotte da alcuni commit esistenti)

         git cherry-pick ec59ab844cf504e462f011c8cc7e5667ebb2e9c7
     

   • O selezionando con cura la gamma di commit per:

     • Prima controlla le modifiche giuste prima di unirle:

       git diff 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
       

     • Prima controlla le modifiche giuste prima di unirle:

       git cherry-pick 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
       

       dove si trova l'intervallo dei commit corretti che hai commesso (esclusa l'unione erroneamente impegnata).

1. git stash

2. git branch -d the_local_branch

3. git checkout -t <name of remote>

4. git stash apply

Questo ha funzionato per me .. !!

Se si nota che è necessario ripristinare immediatamente dopo l'unione e non hai fatto altro dopo il tentativo di unione, si può solo emettere questo comando: git reset --hard HEAD@{1}.

In sostanza, la tua unione shaindicherà HEAD@{0}se nient'altro è stato commesso dopo l'unione e così HEAD@{1}sarà il punto precedente prima dell'unione.

La più semplice delle possibilità più semplici, molto più semplice di qualsiasi altra cosa qui detta:

Rimuovi il tuo ramo locale (locale, non remoto) e tiralo di nuovo. In questo modo annullerai le modifiche sul tuo ramo principale e chiunque sarà interessato dalla modifica che non vuoi spingere. Ricominciare da capo.

In questo caso, dovrai ripristinare il tuo ramo con git reset --hard <branch_name>. Se si desidera salvare le modifiche prima di ripristinarle, assicurarsi di creare un nuovo ramo e git checkout <branch_name>.

Puoi anche reimpostare lo stato su un commit specifico git reset --hard <commit_id>.

Se le modifiche sono state inviate, è possibile utilizzare git revert <branch_name>invece. Assicurati di controllare come usare git revert e git checkout anche in altri scenari.