78 Domanda: Come annullare i commit locali più recenti in Git?

domanda creata a Wed, May 29, 2019 12:00 AM

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

Come posso annullare quei commit dal repository locale?

    
19738
  1. Attenzione: dovresti farlo solo se non hai ancora premuto il commit su un telecomando, altrimenti rovinerai la cronologia di altri che hanno già tirato il commit da il telecomando!
    2015-05-13 21: 18: 57Z
  2. Ecco un post molto chiaro e approfondito su come annullare le cose in git, direttamente da Github.
    2015-06-08 19: 39: 17Z
  3. Prima di pubblicare una nuova risposta, considera che ci sono già 65+ risposte per questa domanda. Assicurati che la tua risposta contribuisca a ciò che non è tra le risposte esistenti.
    2017-06-15 15: 26: 36Z
  4. Sai di cosa ha bisogno git? git undo, il gioco è fatto. Allora il gitano della reputazione ha a che fare con gli errori commessi da noi, i semplici mortali scompaiono. Implementare spingendo lo stato corrente su una pila git prima di eseguire qualsiasi comando git. Influenzerebbe le prestazioni, quindi sarebbe meglio aggiungere un flag di configurazione per abilitarlo.
    2018-03-20 01: 45: 28Z
  5. @ YiminRong Questo può essere fatto con la funzione alias di Git: git-scm.com/book/en/v2/Git-Basics-Git-Aliases
    2018-10-05 14: 50: 08Z
30 risposte                              30                         

Annulla un commit e ripristina

 
$ 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 desideri annullare.
  2. Lascia invariato il tuo albero di lavoro (lo stato dei tuoi file sul disco), ma annulla il commit e lascia le modifiche che hai commesso non programmato (quindi appariranno come "Modifiche non organizzate per il commit" in git status, quindi è necessario aggiungerli di nuovo prima di eseguire il commit). Se solo vuoi aggiungere più modifiche al commit precedente, o cambiare il messaggio di commit 1 , potresti usare invece il git reset --soft HEAD~, che è come git reset HEAD~ (dove HEAD~ è lo stesso di HEAD~1) ma lascia in scena le modifiche esistenti.
  3. Apporta 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. reset copiò la vecchia testina in .git/ORIG_HEAD; commit con -c ORIG_HEAD aprirà un editor, che inizialmente contiene il messaggio di log dal vecchio commit e consente di modificarlo. Se non è necessario modificare il messaggio, è possibile utilizzare l'opzione -C.

Fai attenzione però che se hai aggiunto nuove modifiche all'indice, utilizzando commit --amend le aggiungerai al commit precedente.

Se il codice è già stato inserito nel tuo server e hai le autorizzazioni per sovrascrivere la cronologia (rebase), allora:

 
git push origin master --force

Puoi anche dare un'occhiata a questa risposta:

Come spostarsi Tornate in una posizione precedente? (Testa staccata) & Annulla commit

La risposta sopra mostrerà git reflog che viene usata per scoprire che cos'è lo SHA-1 a cui desideri tornare. Una volta trovato il punto in cui desideri annullare l'uso della sequenza di comandi come spiegato sopra.


1 Nota, tuttavia, che non è necessario ripristinare un commit precedente se hai appena fatto un errore nel tuo messaggio di commit . L'opzione più semplice è git reset (per rimuovere le modifiche che hai apportato da allora) e poi git commit --amend , che aprirà il tuo valore predefinito commettereeditor di messaggi precompilato con l'ultimo messaggio di commit.

    
21340
2019-05-20 20: 06: 45Z
  1. E se il commit era per il ramo sbagliato, puoi git checkout theRightBranch con tutte le fasi di modifica. Come dovevo fare.
    2010-10-05 15: 44: 20Z
  2. Se stai lavorando in DOS, invece di git reset --soft HEAD^ dovrai usare git reset --soft HEAD~1. Il ^ è un carattere di continuazione in DOS quindi non funzionerà correttamente. Inoltre, --soft è il valore predefinito, quindi puoi ometterlo se preferisci e solo dire git reset HEAD~1.
    2011-04-13 14: 15: 10Z
  3. Inoltre, in zsh devi citare ^, quindi git reset --soft 'HEAD^' ... almeno ho fatto
    2011-10-27 18: 24: 16Z
  4. (Correzione di ciò che ho scritto sopra, --mixed è il default --mixed significa mantenere i file modificati, ma non tenerli nell'indice --soft manterrebbe i file modificati e tenerli nell'indice com'erano appena prima del commit modificato. Scusa per la confusione.)
    2011-11-17 02: 40: 53Z
  5. gli utenti zsh potrebbero ottenere: zsh: no matches found: HEAD^ - devi sfuggire ^ ad esempio git reset --soft HEAD\^
    2013-02-21 17: 47: 56Z

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

Di 'questo, dove C è il tuo HEAD e (F) è lo stato dei tuoi file.

 
   (F)
A-B-C
    ↑
  master

Vuoi nuke commettere C e non vederlo più . Fai questo:

 
git reset --hard HEAD~1

Il risultato è:

 
 (F)
A-B
  ↑
master

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

Ah, ma supponiamo che commettere C non sia stato un disastro, ma solo un po 'spento. Devi annullare il commit ma mantenere le modifiche per un po 'di modifica prima di eseguire un commit migliore. Ripartendo da qui, con C come Head:

 
   (F)
A-B-C
    ↑
  master

Puoi farlo, lasciando fuori --hard:

 
git reset HEAD~1

In questo caso il risultato è:

 
   (F)
A-B-C
  ↑
master

In entrambi i casi, HEAD è solo un puntatore all'ultima commit. Quando fai un git reset HEAD~1, dici a Git di spostare il puntatore HEAD indietro di un commit. Ma (a meno che non si usi --hard) si lasciano i file come erano. Quindi ora git status mostra le modifiche che hai controllato in C. Non hai perso nulla!

Per il tocco più leggero, puoi anche annullare il commit ma lasciare i file e il tuo index :

 
git reset --soft HEAD~1

Questo non solo lascia solo i tuoi file, ma lascia il tuo indice solo. Quando fai il git status, vedrai che gli stessi file si trovano nell'indice di prima. Infatti, subito dopo questo comando, potresti fare git commit e dovresti ripetere lo stesso commit che hai appena fatto.

Un'altra cosa: Supponi di distruggere un commit come nel primo esempio, ma poi scopri che ne hai avuto bisogno dopo tutto ? Buona fortuna, vero?

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

 
git checkout -b someNewBranchName shaYouDestroyed

Ora hai resuscitato quel commit. I commit non vengono effettivamente distrutti in Git per circa 90 giorni, quindi di solito puoi tornare indietro e salvare quello che non intendevi eliminare.

    
10293
2018-12-07 09: 56: 29Z
  1. @ dma_k, sì. Oppure potresti fare git reset --hard HEAD^^ una volta. Uso la notazione tilde (~) perché la notazione caret (^) non funziona in DOS.
    2012-02-25 15: 02: 44Z
  2. Un altro buon consiglio: puoi riattaccare the il ramo al commit da cui è stato rimosso con git branch -f <branch> <commit-id>. Salva la necessità di ricreare commit!
    2012-06-22 13: 11: 11Z
  3. Per un principiante git, non è ovvio quale sia la differenza tra le ultime due opzioni (--soft e quella sopra). Menzionare l'indice non aiuta, non sappiamo davvero cosa significhi ancora. La connessione di @ nessur tra soft e Ctrl-Z ha davvero aiutato! Ma ancora non capisco la differenza tra le due opzioni.
    2012-06-26 15: 56: 52Z
  4. È molto meglio dire "perché" qualcosa funziona, oltre alla semplice risposta. Complimenti a questa descrizione - ha aiutato a 'ottenere' git.
    2012-07-03 19: 13: 35Z
  5. Manca un punto cruciale: se il commit è stato precedentemente "spinto" al telecomando, qualsiasi operazione di "annullamento", non importa quanto semplice, causerà un enorme dolore e sofferenza al resto degli utenti che hanno questo commit nella loro copia locale, quando fanno un 'git pull' in futuro. Quindi, se il commit è già stato 'spinto', fallo invece: git revert < bad-commit-sha1-id > origine push git:
    2013-11-08 23: 43: 18Z

Mi ci è voluto un po 'per capire, quindi forse questo aiuterà qualcuno ...

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

Come annullare un commit locale

Diciamo che ho eseguito il commit 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, abbiamo bisogno di reset per il commit prima del 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 log mostrerà 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 commit precedente (corrente HEAD).

 
git revert HEAD

Le tue modifiche verranno ora ripristinate e pronte per il commit:

 
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 maggiori informazioni, consulta Nozioni di base sul Git - Annullare le cose

    
1966
2018-01-30 23: 27: 24Z
  1. Ho trovato questa risposta la più chiara. git revert HEAD^ non è il precedente, è il precedente del precedente. Ho fatto: git revert HEAD e poi spingo di nuovo e ha funzionato:)
    2011-07-14 08: 32: 53Z

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

 
git rm classdir
git add sourcedir

Quindi modifica il commit:

 
git commit --amend

Il commit errato precedente 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 premuto, dovrai solo eseguire il commit di una correzione normalmente.

    
1685
2016-10-12 06: 45: 55Z
  1. Funziona quando ho fatto un git commit --amend e quello che volevo fare era un git commit?
    2011-05-18 13: 07: 31Z
  2. @ dbm, se accidentalmente modificato, usa git reset --soft <oldref>, dove oldref è l'ID di commit prima della modifica. È possibile utilizzare git reflog per identificare il vecchio ID di commit. Questo annullerà gli effetti della modifica, ma lascerà le modifiche in scena. Quindi esegui git commit come commit normale.
    2011-05-18 14: 20: 48Z
  3. @ Dennis, git commit --amend trasforma il corrente tree (cioè, modifiche graduali) in un commit, sovrascrivendo il corrente HEAD. Dopo quel punto, non sono più considerati in scena perché sono parte del commit (cioè, git diff --cached è vuoto), ma non vengono "rimossi" o "persi".
    2012-02-01 03: 08: 06Z
  4. L'opzione --amend era il trucco, per evitare un falso commit!
    2019-03-22 19: 58: 29Z
 
git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

o

 
git reset --hard HEAD~1

Avviso: il comando precedente rimuoverà in modo permanente le modifiche ai file .java (e a qualsiasi altro file) che si desidera salvare.

Il hard reset al HEAD-1 imposterà la tua copia di lavoro nello stato del commit prima del commit sbagliato.

    
954
2017-12-13 22: 03: 28Z
  1. "- hard" si sbarazzerà dei file .java modificati nella directory di lavoro che ha voluto impegnare.
    2009-05-29 18: 26: 59Z
  2. Puoi "git stash save" per cambiare le copie di lavoro, fare un hard reset e poi "git stash pop" per riaverle, anche se suppongo che una reimpostazione soft sarebbe più semplice.
    2011-04-15 13: 33: 03Z
  3. git commit -a -m "" o git commit -am "" naturalmente! :]
    2014-06-21 16: 31: 59Z
  4. Un altro uso "scorciatoia" di stash; se vuoi togliere tutto (cancella git add), solo git stash, quindi git stash pop
    2015-12-08 22: 30: 29Z

Per cambiare l'ultimo commit

Sostituisci i file nell'indice:

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

Quindi, se si tratta di un ramo privato, modifica il commit:

 
git commit --amend

Oppure, se si tratta di un ramo condiviso, crea un nuovo commit:

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


( per modificare un commit precedente , utilizza il fantastico rebase interattivo )


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


Per ripristinare un commit

Modificare un commit è la soluzione ideale se devi cambiare l'ultimo commit, ma una soluzione più generale è reset.

Puoi ripristinare git con qualsiasi commit con:

 
git reset @~N

Dove N è il numero di commit prima del HEAD e @~ si ripristina al commit precedente.

Quindi, invece di modificare il commit, puoi usare:

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

Dai un'occhiata a git help reset, in particolare le sezioni su --soft --mixed e --hard, per una migliore comprensione di ciò che fa.

reflog

Se ti incasina, puoi sempre usare il reflog per trovare i commit abbandonati:

 
$ 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

    
724
2017-05-23 12: 03: 09Z
  1. Per coloro che leggono in futuro - si noti che git revert è un comando separato - che in pratica "ripristina" un singolo commtt.
    2018-08-08 07: 11: 00Z

Usa git revert <commit-id>

Per ottenere l'ID commit, basta usare git log

    
612
2018-11-10 09: 36: 11Z
  1. Se ti sei impegnato nel ramo sbagliato: una volta ripristinato, passa al ramo corretto e seleziona il commit.
    2012-06-27 11: 02: 58Z
  2. Che cosa significa, scegli il commit? Nel mio caso, ero sul ramo sbagliato quando ho modificato un file. L'ho commesso allora mi sono reso conto di essere nel ramo sbagliato. L'utilizzo di "git reset --soft HEAD ~ 1" mi ha riportato a poco prima del commit, ma ora se eseguo il checkout del ramo corretto, come posso annullare le modifiche al file nel ramo sbagliato ma invece renderle (nello stesso nome file) nel ramo corretto?
    2015-01-13 22: 05: 57Z
  3. Ho appena utilizzato git revert commit-id ha funzionato come un incantesimo. Ovviamente quindi dovrai spingere le tue modifiche.
    2016-01-25 21: 07: 16Z
  4. Credo che sarebbe git cherry-pick <<erroneous-commit-sha>> @astronomerdave. Da, Mr. Almost-2-Late-to-the-Party.
    2016-10-20 18: 19: 50Z
  5. @ Kris: invece di cherry-pick usa rebase. Perché è avanzato cherry-picking
    2018-11-10 09: 38: 58Z

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

 
git reset --hard HEAD^1

(Questo comando ignorerà l'intero commit e le tue modifiche andranno completamente perse dall'albero di lavoro locale). Se vuoi annullare il commit, ma vuoi le modifiche nell'area di staging (prima del commit come dopo git add), quindi esegui il seguente comando.

 
git reset --soft HEAD^1

Ora i tuoi file commessi entrano nell'area di staging. Supponiamo che se si desidera eseguire il upstage dei file, poiché è necessario modificare alcuni contenuti errati, eseguire il seguente comando

 
git reset HEAD

Ora i file vengono trasferiti dall'area messa in scena nell'area non palesa. Ora i file sono pronti per essere modificati, quindi qualsiasi cosa tu cambi, vuoi andare a modificare, aggiungerla e creare un nuovo /nuovo commit.

Altro

    
494
2018-09-28 08: 43: 59Z
  1. @ SMR, nel tuo esempio, tutti puntano solo al HEAD corrente. TESTA ^ = TESTA ^ 1. Così come HEAD ^ 1 = HEAD ~ 1. Quando usi HEAD ~ 2, c'è una differenza tra i simboli ~ e ^. Se usi ~ 2 significa "il primo genitore del primo genitore" o "il nonno".
    2015-12-14 15: 34: 11Z

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

    
466
2011-12-13 10: 18: 31Z

Ho voluto annullare gli ultimi 5 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>
    
433
2012-04-06 13: 58: 52Z
  1. La cronologia di riscrittura su un repository condiviso è generalmente una pessima idea. Presumo tu sappia cosa stai facendo, spero solo che anche i futuri lettori lo facciano.
    2012-12-07 16: 02: 12Z
  2. Sì il rollback è pericoloso. Assicurati che la tua copia di lavoro sia nello stato desiderato prima di premere. Quando si preme, i commit indesiderati vengono eliminati definitivamente.
    2012-12-08 14: 14: 43Z
  3. "Proprio come nel mondo reale, se vuoi riscrivere la storia, hai bisogno di una cospirazione: tutti devono essere" in "nella cospirazione (almeno tutti quelli che conosce la storia, cioè tutti quelli che hanno mai tirato fuori dal ramo). " Fonte: stackoverflow.com/a/2046748/334451
    2013-08-07 10: 10: 25Z

Preferisco usare git rebase -i per questo lavoro, perché una bella lista si apre dove 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 inserire gli ultimi tre)

 
git rebase -i HEAD~3

Elenco dei campioni

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

    
412
2018-12-06 21: 59: 20Z

Come correggere il commit locale precedente

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

Come annullare il commit locale precedente

Basta ripristinare il ramo nella posizione precedente (ad esempio, utilizzando gitk o 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ò in un unico comando, usa git reset HEAD~1.

Parola di avviso : L'uso incauto del git reset è un buon modo per trasformare la tua copia di lavoro in uno stato confusionale. Raccomando che i novizi di Git evitino questo se possono.

Come annullare un commit pubblico

Esegui un cherry pick inverso ( git-revert ) per annullare le modifiche.

Se non hai ancora inserito altre modifiche nel tuo ramo, puoi semplicemente fare ...

 
git revert --no-edit HEAD

Quindi inserisci il tuo ramo aggiornato nel repository condiviso.

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


Avanzato: correzione del ramo privato nel repository pubblico

Può essere pericoloso - assicurati di avere 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

Ripulisci localmente il tuo ramo e poi ripieni ...

 
git push origin (branch_name)

Nel caso normale, probabilmente non devi preoccuparti che la cronologia dei commit della tua filiale privata sia incontaminata. Basta inserire un commit successivo (vedi sopra "Come annullare un commit pubblico" sopra) e, successivamente, eseguire un squash-merge per nascondere la cronologia.

    
398
2018-12-07 05: 57: 27Z
  1. gitk --all $(git reflog | cut -c1-7)& può essere utile per trovare la revisione precedente se si desidera annullare un commit '--amend'.
    2014-10-18 23: 38: 11Z
  2. Va notato che se stai tentando di rimuovere le informazioni segrete prima di passare a un repository condiviso, fare un ripristino non ti aiuterà, perché le informazioni rimarranno essere nella cronologia nel commit precedente. Se vuoi assicurarti che la modifica non sia mai visibile agli altri, devi usare git reset
    2015-09-04 04: 52: 01Z
  3. 2016-04-05 04: 20: 04Z
  4. Penso che 'private' /'public' siano più correttamente 'local' /'remote'.
    2018-03-28 14: 59: 27Z
  5. Correzione di un ramo privato nell'archivio remotoory può anche essere fatto semplicemente git push origin (branch_name) --force
    2018-09-07 12: 09: 38Z

Se hai commesso una junk ma non hai premuto,

 
git reset --soft HEAD~1
  

HEAD ~ 1 è una scorciatoia per il commit prima della testa. In alternativa, puoi fare riferimento a SHA-1 dell'hash se desideri reimpostarlo. L'opzione - soft cancellerà il commit ma lascerà tutti i tuoi file modificati "Changes to be committed", come lo avrebbe dichiarato lo stato git.

     

Se vuoi eliminare eventuali modifiche ai file tracciati nell'albero di lavoro poiché il commit prima di testa usa " - hard ".

o

  

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

 
git revert HEAD
  

Questo creerà un nuovo commit che inverte tutto ciò che viene introdotto dal commit accidentale.

    
319
2014-09-25 07: 58: 25Z
  1. Sono nel 2 ° caso, ma quando eseguo "git revert HEAD" dice "errore: Commit [ID] è un'unione ma nessuna opzione -m è stata dato. fatale: ripristino fallito ". Qualche suggerimento?
    2014-11-12 19: 36: 02Z
  2. Probabilmente vale la pena menzionare che invece del HEAD~1 potresti usare l'hash attuale come mostrato da git log --stat o git reflog - utile quando hai bisogno di "annullare" più di un commit.
    2014-12-07 00: 38: 49Z

    Se vuoi annullarlo definitivamente e hai clonato alcuni repository

    L'ID di commit può essere visto da

     
    git log 
    

    Quindi puoi fare -

     
    git reset --hard <commit_id>
    
    git push origin <branch_name> -f
    
        
    316
    2015-06-24 09: 34: 15Z
    1. Che cosa succede se non usi "< commit_id >" e semplicemente usa "git reset --hard"? Solitamente voglio solo sbarazzarmi dei miei ultimi aggiornamenti che non ho ancora effettuato e sono tornato all'ultima commit che ho fatto, e uso sempre "git reset --hard".
      2017-09-27 23: 30: 18Z
    2. @ JaimeMontoya Per annullare le ultime modifiche puoi usare git reset --hard, ma se devi rimuovere duramente l'ultima volta "n" ti impegni specifichi uno SHA
      2017-09-28 13: 10: 31Z

    In SourceTree (GUI per GitHub), puoi fare clic con il tasto destro del mouse sul commit e fare 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.
    
        
    269
    2015-06-24 09: 34: 11Z

    Un singolo comando:

     
    git reset --soft 'HEAD^' 
    

    Funziona alla grande per annullare l'ultimo commit locale!

        
    250
    2014-07-21 20: 13: 34Z
    1. Avevo bisogno di scrivere git reset --soft "HEAD ^" con virgolette doppie, perché lo scrivo dal prompt dei comandi di Windows.
      2014-04-23 09: 13: 35Z
    2. Dovrebbe funzionare senza virgolette.
      2016-11-10 19: 19: 44Z

    Basta resettarlo eseguendo il comando seguente usando git:

     
    git reset --soft HEAD~1
    

    Spiega: cosa fa git reset, in pratica è reset per qualsiasi commit a cui desideri tornare, quindi se lo abbini alla chiave --soft, tornerà indietro, ma manterrai le modifiche in il tuo file (s), in modo da tornare alla fase in cui è stato appena aggiunto il file, HEAD è il capo del ramo e se si combina con ~1 (in questo caso si utilizza anche il HEAD^), tornerà solo un commit quale cosa vuoi ...

    Creo i passaggi nell'immagine sottostante in più dettagli per te, compresi tutti i passaggi che possono accadere in situazioni reali e il commit del codice:

     Come annullare l'ultimo commit in Git?

        
    241
    2017-10-27 12: 46: 34Z

    Come annullare l'ultimo commit Git?

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

    1. Se non vuoi mantenere le modifiche che hai apportato:

       
      git reset --hard HEAD^
      
    2. Se vuoi mantenere le tue modifiche:

       
      git reset --soft HEAD^
      

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

        
    223
    2017-03-25 08: 14: 01Z

    Utilizza il reflog per trovare uno stato corretto

     
    git reflog
    

    reflog before REFLOG PRIMA DI RESETTARE

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

    git reset --hard f3cb6e2
    

    Dopo che il repo HEAD verrà ripristinato su HEADid reset effect LOG AFTER RESET

    Finalmente il reflog appare come nella foto qui sotto

    riflog dopo FINALE REFLOG

        
    180
    2014-01-06 22: 34: 06Z

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

     
    git reset --hard HEAD^ 
    

    "Elimina i file sconosciuti dall'albero di lavoro"

     
    git clean    
    

    see - Riferimento rapido Git

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

        
    173
    2017-12-13 22: 04: 48Z

    Prima esecuzione:

     
    git reflog
    

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

    Quindi fai:

     
    git reset --hard ActionIdFromRefLog
    
        
    156
    2015-06-24 09: 33: 20Z

    Annulla ultimo commit:

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

    Questo annullerà l'ultimo commit.

    Qui --soft significa reset in staging.

    HEAD~ o HEAD^ significa spostare il commit prima di HEAD.


    Sostituisci ultimo commit con nuovo commit:

     
    git commit --amend -m "message"
    

    Sostituirà l'ultimo commit con il nuovo commit.

        
    148
    2017-12-13 22: 05: 20Z

    Un altro modo:

    Controlla il branch vuoi tornare indietro, quindi reimpostare la copia di lavoro locale sul commit che vuoi essere l'ultimo sul server remoto (tutto ciò che seguirà andrà ciao-ciao). Per fare ciò, in SourceTree ho fatto clic con il pulsante destro del mouse su e ho selezionato "Reimposta 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.

        
    143
    2015-06-24 09: 34: 21Z

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

     
    git reset <the previous co>
    
        
    134
    2015-06-24 09: 34: 18Z

    Nel mio caso ho commesso per errore alcuni file che non volevo. Così 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

        
    130
    2015-06-24 09: 34: 09Z

    Semplice, esegui questo nella tua riga di comando:

     
    git reset --soft HEAD~ 
    
        
    121
    2016-01-18 21: 58: 33Z

    Ci sono molti modi per farlo:

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

    Avviso: Non utilizzare --hard se non sai cosa stai facendo. --hard è troppo pericoloso e potrebbe eliminare i tuoi file

    Il comando di base per annullare 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 vuoi ripristinare

    Puoi ottenere l'id di 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 annullare l'ultimo commit 'd81d3f1'. Ecco due opzioni:

     
    $ git reset --hard d81d3f1
    

    o

     
    $ git reset --hard HEAD~1
    

    Supponiamo di voler annullare il commit 'be20eb8':

     
    $ git reset --hard be20eb8
    

    Per informazioni più dettagliate puoi fare riferimento e provare anche altri comandi per reimpostare la testina ad uno stato specificato:

     
    $ git reset --help
    
        
    119
    2018-08-19 14: 00: 16Z
    1. git reset --hard HEAD~1 è troppo pericoloso ! Questo non si limita a "annullare l'ultimo commit", ma ripristinerà completamente il repo al commit precedente. Quindi perderai tutte le modifiche impegnate nell'ultimo commit!
      2017-03-21 12: 09: 47Z
    2. Hai ragione, per annullare puoi usare git push -f <remote> HEAD@{1}:<branch>
      2017-04-24 13: 07: 03Z
    3. Purtroppo, io uso --hard, e i miei file sono cancellati! Non ho controllato prima il commento perché è collassato. Non usare --hard se non sai cosa stai facendo!
      2018-08-19 13: 53: 17Z

    Per un commit locale

     
    git reset --soft HEAD~1
    

    o se non ricordi esattamente in quale commit è, puoi usare

     
    git rm --cached <file>
    

    Per un commit push

    Il modo corretto di rimuovere i file dalla cronologia del repository utilizza git filter-branch. Cioè,

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

    Ma ti raccomando di usare questo comando con cura. Maggiori informazioni su manuale di git-filter-branch (1)Pagina .

        
    117
    2014-07-21 20: 15: 08Z

    Ci sono due scenari principali

    Non hai ancora premuto il commit

    Se il problema riguardava file extra che hai commesso (e non vuoi quelli sul repository), puoi rimuoverli usando git rm e poi eseguendo il commit con --amend

     
    git rm <pathToFile>
    

    Puoi anche rimuovere intere directory con -r, o persino combinare con altri comandi Bash

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

    Dopo aver rimosso i file, puoi eseguire il commit, con l'opzione - modifica

     
    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 su push e saranno anche rimossi dal tuo repository .git locale da GC.

    Hai già premuto il commit

    Puoi applicare la stessa soluzione dell'altro scenario e poi fare git push con l'opzione -f, ma è non raccomandato poiché sovrascrive la cronologia remota con una modifica divergente (può rovinare il tuo repository ).

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

        
    117
    2016-01-11 23: 50: 47Z

    Per ripristinare la revisione precedente, eliminare definitivamente tutte le modifiche non salvate:

     
    git reset --hard HEAD~1
    
        
    117
    2016-09-16 07: 25: 01Z
    1. Forse potresti notare una nota /avvertimento che il suo comando getterà via il commit e le modifiche nella directory di lavoro senza chiedere ulteriori informazioni.
      2014-11-24 22: 35: 29Z
    2. 2014-11-24 22: 40: 57Z
    3. Usa --soft per mantenere le modifiche come uncommitted changes, --hard per nuke completamente il commit e tornare indietro di uno. Ricorda di fare tali operazioni solo su modifiche, che non sono ancora state spinte.
      2015-03-09 09: 11: 06Z
    4. @ Zaz: hai ragione; forse avrei dovuto chiarirlo. Solo i file /modifiche che sono stati aggiunti all'indice (/messo in scena) o sono stati impegnati possono essere recuperati. Le modifiche non inviate e non programmate sono , come hai detto, completamente buttate via git reset --hard.
      21-09-2011: 17: 10Z
    5. Come sidenote: Ogni volta che un file viene messo in scena, git memorizza i suoi contenuti nel suo database degli oggetti. I contenuti memorizzati vengono rimossi solo quando viene eseguita la garbage collection. È quindi possibile ripristinare l'ultima versione a fasi di un file che non è stato messo in scena al momento dell'esecuzione di git reset --hard (vedere i post collegati sopra per ulteriori informazioni).
      21-09-2016 21: 22: 52Z
fonte posta Qui