Come posso annullare gli commit locali più recenti in Git?

Ho accidentalmente eseguito il commit dei file errati su Git , ma non ho ancora inviato il commit al server.

Come posso annullare tali commit dal repository locale?

Annulla un commit e ripeti

$ git commit -m "Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
<< edit files as necessary >>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)

1. Questo è ciò che vuoi annullare.
2. Questo non fa nulla per il tuo albero di lavoro (lo stato dei tuoi file su disco), ma annulla il commit e lascia in scena le modifiche che hai commesso (quindi appariranno come "Modifiche non messe in scena per il commit" git status, quindi dovrai aggiungerli di nuovo prima di impegnarsi). Se solo si desidera aggiungere ulteriori modifiche al precedente commit, o modificare il messaggio di commit ¹ , è possibile utilizzare git reset --soft HEAD~, invece, che è come git reset HEAD~² ma lascia le modifiche esistenti in scena.
3. Apportare correzioni ai file dell'albero di lavoro.
4. git add tutto ciò che desideri includere nel nuovo commit.
5. Conferma le modifiche, riutilizzando il vecchio messaggio di commit. resetcopiò la vecchia testa in .git/ORIG_HEAD; commitcon -c ORIG_HEADaprirà un editor, che inizialmente contiene il messaggio di registro dal vecchio commit e ti permette di modificarlo. Se non è necessario modificare il messaggio, è possibile utilizzare l' -Copzione.

Attenzione, tuttavia, che se sono state aggiunte nuove modifiche all'indice, l'utilizzo commit --amendle aggiungerà al commit precedente.

Se il codice è già stato inviato al tuo server e disponi delle autorizzazioni per sovrascrivere la cronologia (rebase), allora:

git push origin master --force

Puoi anche guardare questa risposta:

Come posso spostare HEAD indietro in una posizione precedente? (Testa distaccata) e Annulla commit

La risposta sopra ti mostrerà git reflog,quale è usato per scoprire cos'è lo SHA-1, che desideri ripristinare. Una volta trovato il punto in cui si desidera annullare, utilizzare la sequenza di comandi come spiegato sopra.

¹ Notare, tuttavia, che non è necessario ripristinare un commit precedente se si è appena commesso un errore nel messaggio di commit . L'opzione più semplice è git reset(per annullare la messa in scena di tutte le modifiche apportate da allora) e quindi git commit --amend, che aprirà l'editor di messaggi di commit predefinito precompilato con l'ultimo messaggio di commit.

² HEAD~ è uguale a HEAD~1. Inoltre, vedi Cos'è HEAD in git? . È utile se si desidera annullare il commit di più commit.

Annullare un commit è un po 'spaventoso se non sai come funziona. Ma in realtà è incredibilmente facile se capisci.

Supponi di avere questo, dove C è il tuo HEAD e (F) è lo stato dei tuoi file.

   (F)
A-B-C
    ↑
  master

Si desidera eseguire il nuke commit C e non vederlo mai più e perdere tutte le modifiche nei file modificati localmente . Tu lo fai:

git reset --hard HEAD~1

Il risultato è:

 (F)
A-B
  ↑
master

Ora B è la TESTA. Poiché hai utilizzato --hard, i tuoi file vengono ripristinati al loro stato al commit B.

Ah, ma supponiamo che commettere C non sia stato un disastro, ma solo un po 'fuori. Tu vuoi annullare il commit ma mantenere le modifiche per un po 'di modifica prima di eseguire un commit migliore. A partire da qui, con C come TESTA:

   (F)
A-B-C
    ↑
  master

Puoi farlo, tralasciando --hard:

git reset HEAD~1

In questo caso il risultato è:

   (F)
A-B-C
  ↑
master

In entrambi i casi, HEAD è solo un puntatore all'ultimo commit. Quando fai ungit reset HEAD~1 , dici a Git di spostare il puntatore HEAD indietro di un commit. Ma (a meno che tu non usi --hard) lasci i tuoi file come erano. Quindi ora git statusmostra le modifiche che hai verificato in C. Non hai perso nulla!

Per il tocco più leggero, puoi persino annullare il commit ma lasciare i tuoi file e il tuo indice :

git reset --soft HEAD~1

Questo non solo lascia i tuoi file da solo, lascia anche solo il tuo indice . Quando lo fai git status, vedrai che gli stessi file sono nell'indice di prima. In effetti, subito dopo questo comando, potresti fare git commite rifaresti lo stesso commit che hai appena avuto.

Ancora una cosa: supponi di distruggere un commit come nel primo esempio, ma poi scopri di averne bisogno dopo tutto ? Buona fortuna, vero?

No, c'è ancora un modo per riaverlo. Digita git refloge vedrai un elenco di shas (parziali) di commit (ovvero hash) in cui ti sei spostato. Trova il commit che hai distrutto e fai questo:

git checkout -b someNewBranchName shaYouDestroyed

Ora hai resuscitato quell'impegno. I commit non vengono effettivamente distrutti in Git per circa 90 giorni, quindi di solito puoi tornare indietro e salvare uno di cui non intendevi sbarazzarti.

Esistono due modi per "annullare" il tuo ultimo commit, a seconda che tu abbia già reso pubblico il tuo commit (inviato al tuo repository remoto):

Come annullare un commit locale

Diciamo che ho commesso localmente, ma ora voglio rimuovere quel commit.

git log
    commit 101: bad commit    # Latest commit. This would be called 'HEAD'.
    commit 100: good commit   # Second to last commit. This is the one we want.

Per ripristinare tutto come prima dell'ultimo commit, è necessario reset eseguire il commit prima di HEAD:

git reset --soft HEAD^     # Use --soft if you want to keep your changes
git reset --hard HEAD^     # Use --hard if you don't care about keeping the changes you made

Ora git logmostrerà che il nostro ultimo commit è stato rimosso.

Come annullare un commit pubblico

Se hai già reso pubblici i tuoi commit, vorrai creare un nuovo commit che "ripristinerà" le modifiche apportate al tuo precedente commit (HEAD corrente).

git revert HEAD

Le modifiche verranno ora ripristinate e pronte per il tuo impegno:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Per ulteriori informazioni, dai un'occhiata a Git Basics - Undoing Things .

Aggiungi / rimuovi file per ottenere le cose nel modo desiderato:

git rm classdir
git add sourcedir

Quindi modificare il commit:

git commit --amend

Il precedente, errato commit verrà modificato per riflettere il nuovo stato dell'indice - in altre parole, sarà come se non avessi mai commesso l'errore in primo luogo.

Nota che dovresti farlo solo se non hai ancora spinto. Se hai spinto, dovrai solo eseguire una correzione normalmente.

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

o

git reset --hard HEAD~1

Avvertenza: il comando sopra rimuoverà permanentemente le modifiche ai .javafile (e qualsiasi altro file) che si desidera eseguire il commit.

Il hard resetto HEAD-1imposterà la tua copia di lavoro sullo stato del commit prima del tuo commit errato.

Per modificare l'ultimo commit

Sostituisci i file nell'indice:

git rm --cached *.class
git add *.java

Quindi, se si tratta di una filiale privata, modificare il commit:

git commit --amend

Oppure, se è un ramo condiviso, effettua un nuovo commit:

git commit -m 'Replace .class files with .java files'

( Per modificare un commit precedente , utilizzare il fantastico rebase interattivo .)

ProTip ™: aggiungi *.classa un gitignore per impedire che ciò accada di nuovo.

Per ripristinare un commit

La modifica di un commit è la soluzione ideale se è necessario modificare l'ultimo commit, ma è una soluzione più generale reset.

Puoi ripristinare Git su qualsiasi commit con:

git reset @~N

Dove si Ntrova il numero di commit precedenti HEADe @~ripristina il commit precedente.

Quindi, invece di modificare il commit, puoi usare:

git reset @~
git add *.java
git commit -m "Add .java files"

Controlla git help reset, in particolare le sezioni su --soft --mixede --hard, per una migliore comprensione di ciò che fa.

reflog

Se sbagli, puoi sempre usare il reflog per trovare i commit rilasciati:

$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started

Usa git revert <commit-id>.

Per ottenere l'ID commit, basta usare git log.

Se stai pianificando di annullare completamente un commit locale, qualunque cosa tu abbia modificato hai fatto sul commit e se non ti preoccupi di nulla, esegui semplicemente il seguente comando.

git reset --hard HEAD^1

(Questo comando ignorerà l'intero commit e le modifiche andranno completamente perse dall'albero di lavoro locale). Se si desidera annullare il commit, ma si desidera apportare le modifiche nell'area di gestione temporanea (prima del commit proprio come dopo git add), eseguire il comando seguente.

git reset --soft HEAD^1

Ora i tuoi file impegnati entrano nell'area di gestione temporanea. Supponiamo che tu voglia mettere in scena i file, perché devi modificare del contenuto sbagliato, quindi esegui il seguente comando

git reset HEAD

Ora i file di cui è stato eseguito il commit provengono dall'area in scena nell'area non in scena. Ora i file sono pronti per essere modificati, quindi qualunque cosa tu modifichi, vuoi modificarli e aggiungerli e fare un nuovo / nuovo commit.

Di Più

Se hai installato Git Extras , puoi eseguire git undoper annullare l'ultimo commit. git undo 3annullerà gli ultimi tre commit.

Volevo annullare gli ultimi cinque commit nel nostro repository condiviso. Ho cercato l'id di revisione a cui volevo eseguire il rollback. Quindi ho digitato quanto segue.

prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt> git push origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To git@bitbucket.org:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>

Preferisco usarlo git rebase -iper questo lavoro, perché appare una bella lista in cui posso scegliere i commit da eliminare. Potrebbe non essere diretto come alcune altre risposte qui, ma sembra giusto .

Scegli quanti commit vuoi elencare, quindi invoca in questo modo (per arruolare gli ultimi tre)

git rebase -i HEAD~3

Elenco di esempio

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Quindi Git rimuoverà i commit per qualsiasi riga rimossa.

Come risolvere il precedente commit locale

Usa git-gui (o simile) per eseguire a git commit --amend. Dalla GUI è possibile aggiungere o rimuovere singoli file dal commit. Puoi anche modificare il messaggio di commit.

Come annullare il precedente commit locale

Basta reimpostare il ramo nella posizione precedente (ad esempio, utilizzando gitko git rebase). Quindi riapplica le modifiche da una copia salvata. Dopo la garbage collection nel tuo repository locale, sarà come se il commit indesiderato non fosse mai avvenuto. Per fare tutto ciò con un solo comando, usa git reset HEAD~1.

Avvertenza : un uso noncurante di git resetè un buon modo per portare la copia di lavoro in uno stato confuso. Consiglio ai principianti di Git di evitarlo se possono.

Come annullare un commit pubblico

Esegui una selezione inversa della ciliegia ( git-revert ) per annullare le modifiche.

Se non hai ancora apportato altre modifiche al tuo ramo, puoi semplicemente fare ...

git revert --no-edit HEAD

Quindi spingere il ramo aggiornato nel repository condiviso.

La cronologia dei commit mostrerà entrambi i commit, separatamente .

Avanzato: correzione della filiale privata nel repository pubblico

Questo può essere pericoloso: assicurati di disporre di una copia locale del ramo da respingere.

Nota anche: non vuoi farlo se qualcun altro potrebbe lavorare sul ramo.

git push --delete (branch_name) ## remove public version of branch

Pulisci il tuo ramo localmente quindi ripeti ...

git push origin (branch_name)

Nel caso normale, probabilmente non devi preoccuparti che la cronologia dei commit della tua filiale privata sia incontaminata. Basta inviare un commit di follow-up (vedere 'Come annullare un commit pubblico' sopra) e, successivamente, eseguire una fusione-squash per nascondere la cronologia.

Se vuoi annullarlo definitivamente e hai clonato un repository

L'ID commit può essere visto da

git log 

Quindi puoi fare -

git reset --hard <commit_id>

git push origin <branch_name> -f

Se hai commesso spazzatura ma non hai spinto,

git reset --soft HEAD~1

HEAD ~ 1 è una scorciatoia per il commit prima di head. In alternativa, è possibile fare riferimento a SHA-1 dell'hash se si desidera ripristinare. L' opzione --soft cancellerà il commit ma lascerà tutti i tuoi file modificati "Modifiche da impegnare", come direbbe lo stato git.

Se vuoi sbarazzarti di qualsiasi modifica ai file tracciati nell'albero di lavoro dal commit prima di head usa invece " --hard ".

O

Se hai già spinto e qualcuno ha tirato, che di solito è il mio caso, non puoi usare git reset . Puoi comunque fare un ripristino git ,

git revert HEAD

Ciò creerà un nuovo commit che inverte tutto ciò che è stato introdotto dal commit accidentale.

Su SourceTree (GUI per GitHub), è possibile fare clic con il pulsante destro del mouse sul commit ed eseguire un "Reverse Commit". Questo dovrebbe annullare le tue modifiche.

Sul terminale:

In alternativa puoi usare:

git revert

O:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

Un singolo comando:

git reset --soft 'HEAD^' 

Funziona benissimo per annullare l'ultimo commit locale!

Basta resettarlo facendo il comando seguente usando git:

git reset --soft HEAD~1

Spiega: che cosa git resetsuccede, è fondamentalmente reseta qualsiasi commit a cui desideri tornare, quindi se lo combini con la --softchiave, tornerà indietro, ma mantieni le modifiche nei tuoi file, quindi torni sul palco che il file è stato appena aggiunto, HEADè il capo del ramo e se lo si combina ~1(in questo caso si usa anche HEAD^), tornerà solo un commit che quello che vuoi ...

Creo i passaggi nell'immagine di seguito in maggiori dettagli per te, inclusi tutti i passaggi che possono accadere in situazioni reali e il commit del codice:

Come annullare l'ultimo commit Git?

Per ripristinare tutto come prima dell'ultimo commit, è necessario reimpostare il commit prima di HEAD.

1. Se non desideri conservare le modifiche apportate:

   git reset --hard HEAD^
   

2. Se desideri mantenere le modifiche:

   git reset --soft HEAD^
   

Ora controlla il tuo registro git. Mostrerà che il nostro ultimo commit è stato rimosso.

"Ripristina l'albero di lavoro sull'ultimo commit"

git reset --hard HEAD^ 

"Pulisci i file sconosciuti dall'albero di lavoro"

git clean    

vedi - Riferimento rapido Git

NOTA: questo comando cancellerà il tuo precedente commit, quindi usa con cautela! git reset --hardè più sicuro.

Utilizzare reflog per trovare uno stato corretto

git reflog

RICARICA PRIMA DEL RESET

Seleziona il reflog corretto (f3cb6e2 nel mio caso) e digita

git reset --hard f3cb6e2

Successivamente il repository HEAD verrà ripristinato su quel HEADid LOG DOPO IL RESET

Finalmente il reflog assomiglia all'immagine qui sotto

FINAL REFLOG

Prima corsa:

git reflog

Ti mostrerà tutte le possibili azioni che hai eseguito sul tuo repository, ad esempio commit, unisci, pull, ecc.

Quindi fa:

git reset --hard ActionIdFromRefLog

Annulla l'ultimo commit:

git reset --soft HEAD^ o git reset --soft HEAD~

Questo annullerà l'ultimo commit.

Qui --softsignifica ripristinare la messa in scena.

HEAD~o HEAD^significa spostarsi per impegnarsi prima di HEAD.

Sostituisci ultimo commit con nuovo commit:

git commit --amend -m "message"

Sostituirà l'ultimo commit con il nuovo commit.

Un altro modo:

Controlla il ramo che desideri ripristinare, quindi reimposta la tua copia di lavoro locale sul commit che desideri sia l'ultimo sul server remoto (tutto ciò che segue andrà via ciao). Per fare ciò, in SourceTree ho fatto clic con il tasto destro del mouse sul e ho selezionato "Ripristina BRANCHNAME su questo commit".

Quindi vai alla directory locale del tuo repository ed esegui questo comando:

git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

Questo cancellerà tutti i commit dopo quello corrente nel tuo repository locale ma solo per quel ramo.

Digita git loge trova l'ultimo codice hash di commit, quindi inserisci:

git reset <the previous co>

Nel mio caso ho commesso accidentalmente alcuni file che non volevo. Quindi ho fatto quanto segue e ha funzionato:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Verifica i risultati con gitk o git log --stat

Semplice, eseguilo nella tua riga di comando:

git reset --soft HEAD~ 

Ci sono molti modi per farlo:

Comando Git per annullare l'ultimo commit / commit precedenti:

Avvertenza: non usare --hard se non sai cosa stai facendo. --hard è troppo pericoloso e potrebbe eliminare i tuoi file.

Il comando di base per ripristinare il commit in Git è:

$ git reset --hard <COMMIT -ID>

o

$ git reset --hard HEAD~<n>

COMMIT-ID : ID per il commit

n: è il numero degli ultimi commit che desideri ripristinare

È possibile ottenere l'ID commit come mostrato di seguito:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

dove d81d3f1 e be20eb8 sono id commit.

Ora vediamo alcuni casi:

Supponiamo di voler ripristinare l'ultimo commit 'd81d3f1'. Ecco due opzioni:

$ git reset --hard d81d3f1

o

$ git reset --hard HEAD~1

Supponiamo di voler ripristinare il commit 'be20eb8':

$ git reset --hard be20eb8

Per informazioni più dettagliate è possibile fare riferimento e provare anche alcuni altri comandi per ripristinare la testa su uno stato specificato:

$ git reset --help

Per un impegno locale

git reset --soft HEAD~1

o se non ricordi esattamente in quale commit è, potresti usarlo

git rm --cached <file>

Per un commit push

Viene utilizzato il modo corretto di rimuovere i file dalla cronologia del repository git filter-branch. Questo è,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

Ma ti consiglio di usare questo comando con cura. Maggiori informazioni alla pagina del manuale di git-filter-branch (1) .

Esistono due scenari principali

Non hai ancora inviato il commit

Se il problema riguardava file extra che hai git rmeseguito il commit (e non li desideri nel repository), puoi rimuoverli utilizzando e quindi eseguendo il commit con--amend

git rm <pathToFile>

Puoi anche rimuovere intere directory con -ro persino combinarle con altri comandi di Bash

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

Dopo aver rimosso i file, è possibile eseguire il commit, con l' opzione --amend

git commit --amend -C HEAD # the -C option is to use the same commit message

Questo riscriverà il tuo recente commit locale rimuovendo i file extra, quindi questi file non verranno mai inviati in push e verranno rimossi dal tuo repository .git locale da GC.

Hai già spinto il commit

È possibile applicare la stessa soluzione dell'altro scenario e quindi fare git pushcon l' -fopzione, ma non è consigliabile poiché sovrascrive la cronologia remota con una modifica divergente (può rovinare il repository).

Invece, devi fare il commit senza --amend(ricorda questo di -amend`: quell'opzione riscrive la cronologia sull'ultimo commit).

Per ripristinare la revisione precedente, eliminando definitivamente tutte le modifiche non impegnate:

git reset --hard HEAD~1