Come annullare i commit più recenti in Git?

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

Diciamo che hai 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ù. Tu lo fai:

git reset --hard HEAD~1

Il risultato è:

 (F)
A-B
  ↑
master

Ora B è il TESTA. Poiché hai usato --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. Si desidera annullare il commit ma mantenere le modifiche per un po 'di modifica prima di eseguire un commit migliore. Ripartendo da qui, con C come TESTO:

   (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 esegui un git reset HEAD~1, comunichi a Git di spostare il puntatore HEAD indietro di un commit. Ma (a meno che tu non usi --hard) lasci i tuoi file così come sono. 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 tuo commit ma lasciare i tuoi file e il tuo index:

git reset --soft HEAD~1

Questo non solo lascia solo i tuoi file, ma lascia il tuo index solo. Quando esegui git status, vedrai che gli stessi file si trovano nell'indice di prima. Infatti, subito dopo questo comando, potresti fare git commit e dovrai 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, giusto?

No, c'è ancora un modo per riaverlo. Scrivi git reflog e vedrai una lista di commit (parziali) shas (cioè 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 uno di cui non volevi liberarti.

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

Ci sono due modi per "annullare" l'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 riportare tutto al modo in cui era prima dell'ultimo commit, dobbiamo reset al 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 log mostrerà che il nostro ultimo commit è stato rimosso.

Come annullare un commit pubblico

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

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

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 spinto, dovrai semplicemente 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

Avviso: il comando precedente rimuoverà in modo permanente le modifiche ai file .Java (e qualsiasi altro file) che si desidera eseguire il commit.

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

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, effettua un nuovo commit:

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

(per cambiare un commit precedente, usa il fantastico rebase interattivo )

ProTip ™: Aggiungi *.class a un gitignore per fermare questo evento 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 con qualsiasi commit con:

git reset @~N

Dove N è il numero di commit prima di HEAD, e @~ si reimposta al 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--mixed e --hard, per una migliore comprensione di ciò che fa.

Reflog

Se si incasina, è sempre possibile utilizzare il reflog per trovare i commit abbandonati:

$ git reset @~
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~
2c52489 [email protected]{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, usa solo git log

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 si desidera annullare il commit, ma si desidera apportare le modifiche nell'area di gestione temporanea (prima di eseguire il commit come dopo git add), eseguire il comando seguente.

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.

Di Più

Se hai Git Extras installed, puoi eseguire git undo per annullare l'ultimo commit. git undo 3 annulla gli ultimi 3 commit.

Volevo annullare l'ultimo 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 [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
Prompt>

Preferisco usare git rebase -i per 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 solo sembra giusto .

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

git rebase -i HEAD~3

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

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.

Word of warning: L'uso incondizionato di 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 reverse cherry pick ( 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 invia il tuo ramo aggiornato al repository condiviso.

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

Avanzate: correzione del ramo private 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

Pulisci localmente il tuo ramo e poi ripletti ...

git Push Origin (branch_name)

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

Se hai commesso spazzatura ma non spinto,

git reset --soft HEAD~1

HEAD ~ 1 è una scorciatoia per il commit prima della testa. 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 "Changes to be committed", come lo metterebbe lo stato git.

Se si desidera eliminare eventuali modifiche ai file rilevati nell'albero di lavoro dal momento che il commit prima di utilizzare " --hard ", invece.

OR

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

git revert HEAD

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

Se vuoi annullarlo definitivamente e hai clonato alcuni repository 

L'ID di commit può essere visto da 

git log 

Allora puoi fare -

git reset --hard <commit_id>

git Push Origin <branch_name> -f

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

Un singolo comando:

git reset --soft 'HEAD^' 

Funziona alla grande per annullare l'ultimo commit locale!

Basta resettarlo facendo il seguente comando usando git:

git reset --soft HEAD~1

Spiega: cosa fa git reset, è fondamentalmente reset per qualsiasi commit a cui desideri tornare, quindi se lo abbini a --soft key, tornerà indietro, ma manterrai le modifiche nei tuoi file, così si ritorna allo stage in cui è stato appena aggiunto il file, HEAD è il capo del ramo e se si combina con ~1 (in questo caso si utilizza anche HEAD^), si tornerà indietro di un solo commit che cosa si desidera .. .

Creo i passaggi nell'immagine sottostante in ulteriori dettagli per te, compresi 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 ripristinare il commit prima di HEAD.

1. Se non vuoi mantenere le tue modifiche che hai fatto:

   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.

Usa il reflog per trovare uno stato corretto

git reflog

REFLOG PRIMA DI RESET

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

git reset --hard f3cb6e2

Successivamente, il repository HEAD verrà reimpostato su HEADid LOG DOPO RESET

Finalmente il reflog sembra l'immagine qui sotto

REFLOG FINALE

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

git reset --hard HEAD^ 

"Pulisci i file sconosciuti dall'albero di lavoro"

git clean    

vedi - Git Quick Reference

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

Prima corsa: 

git reflog

Ti mostrerà tutte le possibili azioni che hai eseguito sul tuo repository, ad esempio, commetti, unisci, tira, 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 --soft significa reset in staging.

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

Sostituisci l'ultimo commit con il nuovo commit:

git commit --amend -m "message"

Sostituirà l'ultimo commit con il nuovo commit.

Un altro modo:

Esegui il checkout del ramo che desideri ripristinare, quindi reimposta la copia di lavoro locale sul commit che desideri essere l'ultimo sul server remoto (tutto ciò che seguirà andrà via 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 accedere alla directory locale del repository ed eseguire 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.

Digitare git log e trovare l'ultimo codice di hash di commit e quindi immettere:

git reset <the previous co>

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

Usa SourceTree (strumento grafico per Git) per vedere il tuo commit e albero. È possibile ripristinarlo manualmente facendo clic con il pulsante destro del mouse.

Semplice, esegui questo nella tua riga di comando:

git reset --soft HEAD~ 

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

git reset --hard HEAD~1

Ci sono due scenari principali

Non hai ancora spinto 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 anche combinarle 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 --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 saranno mai inviati su Push e saranno anche rimossi dal tuo repository .git locale da GC.

Hai già spinto il commit

È possibile applicare la stessa soluzione dell'altro scenario e quindi eseguire git Push con l'opzione -f, ma è non consigliato poiché sovrascrive la cronologia remota con una modifica divergente (può danneggiare il repository).

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

Ci sono molti modi per farlo:

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

Attenzione: Non usare --hard se non sai cosa stai facendo .-- hard è troppo pericoloso , e potrebbe cancellare 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 si desidera 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 è possibile fare riferimento e provare anche altri comandi per reimpostare la testina in uno stato specificato:

$ git reset --help

Per un commit locale

git reset --soft HEAD~1

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

git rm --cached <file>

Per un commit spinto

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

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

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

COSA USARE, reset --soft o reset --hard?

Sto solo aggiungendo due centesimi per la risposta di @ Kyralessa:

Se non sei sicuro di cosa usare vai per --soft (ho usato questa convenzione per ricordarlo --s oft per sicurezza).

Perché ?

Se scegli --hard per errore, perdi PERDERÀ le tue modifiche come non lo erano prima . Se scegli --soft per errore puoi ottenere gli stessi risultati di --hard applicando comandi aggiuntivi

git reset HEAD file.html
git checkout -- file.html

Esempio completo

echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

I crediti vanno a @Kyralessa.

Puoi usare:

git reset [email protected]{1}

Questo comando cancellerà il commit sbagliato senza un log Git.

Pensa di avere code.txt file . Apportiamo alcune modifiche e commit .Possiamo annullare questo commit in tre modi, ma prima dovresti sapere qual è il file in scena .... Un file in scena è un file pronto per il commit e se si esegue git status questo file verrà visualizzato con il colore verde e se non viene messo in scena per il commit verrà mostrato con il colore rosso:

Significa che se commetti la tua modifica, le tue modifiche su questo file non vengono salvate . Puoi aggiungere questo file sul tuo stage con git add code.txt e quindi confermare la tua modifica:

Annulla ultimo commit:

1. Ora se vogliamo annullare solo commit senza altre modifiche, possiamo usarlo

   git reset --soft HEAD^ 

    

2. Se vogliamo annullare commit e le sue modifiche (THIS IS DANGEROUS, perché la tua modifica verrà persa), possiamo usare

   git reset --hard HEAD^

    

3. E se vogliamo annullare il commit e rimuovere le modifiche dallo stage, possiamo usarlo

   git reset --mixed HEAD^ o in forma abbreviata git reset HEAD^

    

Di solito, si desidera annullare un commit perché si è commesso un errore e si desidera risolverlo - in sostanza ciò che l'OP ha fatto quando ha posto la domanda. Quindi davvero, in realtà vuoi redo un commit.

La maggior parte delle risposte qui si concentrano sulla riga di comando. Mentre la riga di comando è il modo migliore per usare Git quando ci si sente a proprio agio, è probabilmente un po 'estraneo a quelli che provengono da altri sistemi di controllo delle versioni di Git. 

Ecco come farlo usando una GUI. Se hai installato Git, hai già tutto ciò che ti serve per seguire queste istruzioni.

NOTA: assumerò qui che hai capito che il commit era sbagliato prima che tu lo spingessi. Se non sai cosa è la spinta, probabilmente non hai spinto, quindi continua con le istruzioni. Se hai commesso il commit errato, il modo meno rischioso è solo di seguire il commit errato con un nuovo commit che corregge le cose, come faresti in un sistema di controllo delle versioni che non ti permette di riscrivere la cronologia. 

Detto questo, ecco come correggere il tuo errore di errore più recente utilizzando una GUI:

1. Passare al repository sulla riga di comando e avviare la GUI con git gui
2. Scegli "Modifica ultimo commit". Vedrai il tuo ultimo messaggio di commit, i file che hai messo in scena e i file che non hai fatto.
3. Ora cambia le cose per come vuoi che guardino e fai clic su Conferma. 

Annullare l'ultimo commit: 

git reset --soft HEAD~

O annullare l'ora prima che l'ultima volta si impegni: 

git reset --soft HEAD~2

O annullare qualsiasi commit precedente: 

git reset --soft <commitID>

(puoi ottenere il commitID usando git reflog)

Quando annulli un commit precedente, ricorda di pulire il posto di lavoro con

git clean

Maggiori dettagli possono essere trovati nei documenti: git-reset

Se stai lavorando con SourceTree, questo ti aiuterà.

Fare clic con il pulsante destro del mouse sul commit quindi selezionare "Ripristina (ramo corrente)/master su questo commit" e ultimo selezionare _ ​​Ripristino "Soft" .

Annulla l'ultimo commit

Ci sono un sacco di situazioni in cui si desidera davvero annullare l'ultimo commit nel codice. Per esempio. perché ti piacerebbe ristrutturarlo ampiamente - o addirittura scartarlo del tutto!

In questi casi, il comando "reset" è il tuo migliore amico:

$ git reset --soft HEAD~1

Il comando precedente (ripristino) riavvolgerà il ramo HEAD corrente alla revisione specificata. Nel nostro esempio sopra, vorremmo tornare a quello precedente alla revisione attuale, annullando in modo efficace il nostro ultimo commit.

Nota il flag --soft: questo assicura che le modifiche alle revisioni annullate siano preservate. Dopo aver eseguito il comando, troverai le modifiche come modifiche locali non vincolate nella tua copia di lavoro.

Se non vuoi mantenere queste modifiche, usa semplicemente il flag --hard. Assicurati di farlo solo quando sei sicuro di non aver più bisogno di queste modifiche.

$ git reset --hard HEAD~1

Per annullare il commit locale usi git reset <commit>. Anche questo tutorial è molto utile per mostrarti come funziona.

In alternativa, è possibile utilizzare git revert <commit>: reverting deve essere utilizzato quando si desidera aggiungere un altro commit che ripristini le modifiche (ma le mantiene nella cronologia del progetto).

Un tipico ciclo Git

Parlando di comandi relativi a Git nelle risposte precedenti, vorrei condividere i miei tipici cicli Git con tutti i lettori che potrebbero essere utili. Ecco come lavoro con Git,

1. Clonazione la prima volta dal server remoto

   git clone $project

2. Tirando da remoto (quando non ho un commit locale in attesa di Push)

   git pull

3. Aggiunta di un nuovo file locale1 in $ to_be_committed_list (solo immaginare $ to_be_committed_list significa staged area)

   git add $file1

4. Rimozione erroneamente aggiunto file2 da $ to_be_committed_list (si supponga che file2 sia aggiunto come il punto 3, che non volevo)

   git reset $file2

5. Committing file1 che si trova in $ to_be_committed_list

   git commit -m "commit message description"

6. Sincronizzare il commit locale con il repository remoto prima di premere

   git pull --rebase

7. Risoluzione in caso di conflitto prerequisito configura mergetool

   git mergetool #resolve merging here, also can manually merge

8. Aggiunta di file risolti in conflitto, supponiamo file1:

   git add $file1

9. Continuando il mio precedente comando di rebase

   git rebase --continue

10. Spingendo pronto e già sincronizzato l'ultimo commit locale

    git Push Origin head:refs/for/$branch # branch = master, dev, etc.

Nel mio caso mi sono impegnato e spinto al ramo sbagliato, quindi quello che volevo era avere tutti i miei cambiamenti indietro in modo da poterli affidare a un nuovo ramo corretto, così ho fatto questo:

Sullo stesso ramo che hai commesso e spinto, se digiti "git status" non vedrai nulla di nuovo perché hai commesso e inviato, ora scrivi:

git reset --soft HEAD~1

Questo riporterà tutte le tue modifiche (file) nell'area del palco, ora per rimetterle nella directory di lavoro (nonstage) devi solo digitare:

git reset FILE

Dove "File" è il file che si desidera ripetere nuovamente. Ora questo FILE dovrebbe essere nella directory di lavoro (non inattivo) con tutte le modifiche che hai fatto. Ora puoi cambiare qualsiasi ramo desiderato e commettere le modifiche in quel ramo. Spero che questo aiuti altre persone che hanno fatto lo stesso errore che ho fatto. Ovviamente il ramo iniziale che hai commesso è ancora lì con tutte le modifiche, ma nel mio caso era ok, se non è per te puoi cercare modi per ripristinare quel commit in quel ramo.

UTENTI DI VISUAL STUDIO (2015, ecc.)

Se non è possibile eseguire la sincronizzazione in Visual Studio poiché non è consentito il push su un ramo come "sviluppo", allora quanto ho provato, in Visual Studio NEITHER ilRIPRISTINANOR ilRESET(duro o morbido) funzionerebbe.

Per la risposta con TONNELLATE DI VOTI:

Usa questo comando al prompt Prompt di root del tuo progetto per nuke qualsiasi cosa proverà ad essere spinta:

git reset --hard HEAD~1

Backup o Zip dei tuoi file nel caso in cui non desideri perdere alcun lavoro, ecc ...

Ho ottenuto l'ID di commit da bitbucket e poi ho fatto:

git checkout commitID .

Esempio:

git checkout 7991072 .

E ha ripristinato il backup su quella copia funzionante di quel commit.

Supponiamo di aver fatto un commit locale sbagliato e di averlo spinto su un repository remoto. Puoi annullare il pasticcio con questi due comandi:

Per prima cosa, dobbiamo correggere il nostro repository locale tornando al commit che desideriamo:

git reset --hard <previous good commit id where you want the local repository  to go>

Ora forziamo con forza questa buona commit sul repository remoto usando questo comando:

git Push --force-with-lease

La versione 'with-lease' dell'opzione force preverrà la cancellazione accidentale di nuovi commit che non conosci (cioè che provengono da un'altra fonte dopo l'ultima estrazione).

Annulla ultimo commit:

git reset --soft HEAD^ or git reset --soft HEAD~

Questo annullerà l'ultimo commit.

Qui --soft significa reset in staging.

HEAD~ or HEAD^ indica di passare al commit prima di HEAD.

Sostituisci l'ultimo commit con il nuovo commit:

git commit --amend -m "message"

Sostituirà l'ultimo commit con il nuovo commit.

Devi fare il facile e veloce

    git commit --amend

se si tratta di un ramo privato o

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

se è una filiale pubblica o condivisa.

Hai diverse opzioni per annullare l'ultimo commit. Ecco alcune delle opzioni che riassumono in una singola risposta con frammenti di codice

Prima di tutto devi capire quali sono i commit "sbagliati" che vuoi scartare. Useremo git reflog per trovarlo.

git reflog

Puoi sempre usare anche reflog.
git reflog visualizzerà tutte le modifiche che hanno aggiornato HEAD e verificando la voce di reflog desiderata imposterà HEAD su questo commit. 

Ogni volta che HEAD viene modificato ci sarà una nuova voce in reflog.
Il reflog è simile al comando di cronologia unix e viene mantenuto localmente sulla macchina.

git reflog
git checkout [email protected]{...}
# or
git checkout <sha-1>

Usando il checkout puoi tornare a qualsiasi commit desiderato e puoi creare branch o qualsiasi altra opzione che git checkout ti permetterà di fare.

git reset HEAD --hard <commit_id>

"Sposta" la tua testa torna al commit desiderato.
Git reset eseguirà il checkout del contenuto di commit desiderato nell'area di staging e/o nella directory di lavoro in base al valore --hard/--soft/--mixed che scegli di selezionare. --hard aggiornerà sia l'area stage che la directory di lavoro con il contenuto dato e "scollegherà" qualsiasi altro commit oltre questo punto sul ramo locale. 

Se quei commit non fanno parte di nessun altro ramo diventeranno "dangle".
Il contenuto "penzoloni" significa che esiste un contenuto non raggiungibile nel proprio repository locale che non fa parte di nessun altro ramo e che può essere rimosso o rimosso dal gc.

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

Questo schema illustra quale comando fa cosa.
Come puoi vedere qui reset && checkout modifica HEAD.

Usa questo comando:

git checkout -b old-state number_commit

Usa questo comando

git checkout -b old-state 0d1d7fc32

Rimuove un commit errato che è già stato inviato a Github

git Push Origin +(previous good commit id):(branch name)

Specifica l'ultimo ID commit valido che desideri ripristinare in Github.

Per esempio. Se l'ID di commit più recente è errato, specificare l'ID di commit precedente sopra il comando git con il nome del ramo. 

Puoi ottenere l'ID di commit precedente utilizzando git log

Per sbarazzarsi di (tutte le modifiche in) l'ultimo commit, l'ultimo 2 commit e l'ultimo n commit:

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

E, per sbarazzarsi di qualsiasi cosa dopo uno specifico commit:

git reset --hard <commit sha>

per esempio., 

git reset --hard 0d12345

PS:
1- Fai attenzione, a causa dell'opzione "difficile", elimina le modifiche locali nel tuo repo pure e ritorna al commit precedentemente menzionato. Tu dovrebbe essere eseguito se sei sicuro di aver incasinato l'ultimo commit (s) e vorrei tornare indietro nel tempo. 

2- Solitamente 7 lettere di "commit sha" sono sufficienti, ma in più grandi progetti, potresti aver bisogno di un massimo di 12 lettere per essere unico. Tu inoltre posso menzionare tutte le 40 lettere sha.

3- I comandi precedenti funzionano anche in Github per Windows.

Puoi sempre fare un git checkout <SHA code> della versione precedente e poi eseguire nuovamente il commit con il nuovo codice.

È possibile annullare il commit Git in due modi: Innanzitutto è possibile utilizzare git revert, se si desidera mantenere la cronologia dei commit:

git revert HEAD~3
git revert <hashcode of commit>

Secondo è possibile utilizzare git reset, che cancellerebbe tutta la cronologia dei commit e porterà la tua testa a commettere dove vuoi.

git reset <hashcode of commit>
git reset HEAD~3

Puoi anche utilizzare la parola chiave --hard se qualcuno inizia a comportarsi diversamente. Ma lo consiglierei solo fino a quando non sarà estremamente necessario.

Riferimento: Come annullare l'ultimo commit in Git?

Se hai installato Git Extensions puoi facilmente annullare/annullare qualsiasi commit (puoi scaricare le estensioni git da here ).

Apri Git Extensions, fai clic con il tasto destro sul commit che vuoi ripristinare e seleziona "Revert commit". 

Verrà aperto un popup (vedi la schermata qui sotto)

Seleziona "Crea automaticamente un commit" se vuoi impegnare direttamente le modifiche ripristinate o se vuoi commettere manualmente le modifiche ripristinate, tieni la casella non selezionata e fai clic sul pulsante "Ripristina questo commit".

Basta usare git reset --hard <last good SHA> per resettare le modifiche e dare nuovi commit. Puoi anche usare git checkout -- <bad filename>.

Ho trovato this site che descrive come annullare le cose che hai commesso nel repository.

Alcuni comandi:

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit

Ecco il sito: Oh shit, git! .

Ecco molte ricette su come annullare le cose in Git. Alcuni di quelli:

Oh merda, ho bisogno di cambiare il messaggio sul mio ultimo impegno!

git commit --amend
# follow prompts to change the commit message

Oh merda, ho accidentalmente commesso qualcosa da padroneggiare che avrebbe dovuto essere su una nuova filiale!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)

Puoi annullare i tuoi commit dal repository locale. Si prega di seguire lo scenario sottostante.

Nell'immagine qui sotto, controllo il ramo 'test' (usando il comando Git git checkout -b test) come locale e controllo lo stato (usando il comando Git git status) del ramo locale che non c'è nulla da impegnare.

Nella prossima immagine dell'immagine potete vedere qui ho apportato alcune modifiche in Filter1.txt e aggiunto quel file all'area di staging e poi ho eseguito il commit delle mie modifiche con un messaggio (usando il comando Git git commit -m "Doing commit to test revert back").

"-m è per il messaggio di commit"

Nell'immagine successiva puoi vedere i tuoi commit che registrano qualsiasi cosa tu abbia commesso (usando il comando Git git log).

Quindi nell'immagine sopra puoi vedere l'id di commit con ogni commit e con il tuo messaggio di commit ora qualunque commit vuoi ripristinare o annullare copy that commit id e premi il comando Git di sotto, git revert {"paste your commit id"}. Esempio:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

Ho ripristinato il mio ultimo impegno. Ora se controlli lo stato Git, puoi vedere il file modificato che è Filter1.txt e ancora impegnarsi.

Il modo più semplice per annullare l'ultimo commit è

git reset HEAD^

Ciò porterà lo stato del progetto prima di aver effettuato il commit.

In IntelliJ IDEA puoi semplicemente aprire il registro del repository Git premendo Alt+9, fai clic con il pulsante destro del mouse su un tag dall'elenco dei commit e seleziona: "Reimposta ramo attuale qui ...".

CAPO:

Prima di resettare commit dovremmo sapere HEAD ... HEAD non è altro che il tuo stato attuale nella tua directory di lavoro. È rappresentato da un numero di commit.

Git commit:

Ogni cambiamento assegnato sotto un commit che è rappresentato da un tag unico. I commit non possono essere cancellati. Quindi se vuoi il tuo ultimo commit, puoi semplicemente immergerti usando git reset.

Puoi immergerti nell'ultimo commit utilizzando due metodi:

Metodo 1: (se non si conosce il numero di commit, ma si desidera passare al primo)

git reset HEAD~1  # It will move your head to last commit

Metodo 2: (se conosci il commit, resetti semplicemente sul tuo commit noto)

git reset 0xab3 # numero di commit

Nota: se vuoi conoscere un recente commit prova git log -p -1

Ecco la rappresentazione grafica:

La differenza tra git reset --mixed, --soft e --hard

Prerequisito: quando si modifica un file esistente nel proprio repository è fatto, questo cambiamento è inizialmente considerato come non cancellato . Al fine di commettere i cambiamenti, deve essere messo in scena che significa aggiungendolo all'indice usando git add. Durante un'operazione di commit, il i file che vengono messi in scena vengono aggiunti a un indice.

Facciamo un esempio: 

- A - B - C (master)

HEAD punta a C e l'indice corrisponde C.

--soft

• Quando eseguiamo git reset --soft B con l'intenzione di rimuovere il commit C e puntare il master/HEAD su B. 
• Ora il master/HEAD punta a B, ma l'indice è ancora cambiato da C. 
• Quando esegui git status puoi vedere i file indicizzati in commit C come staged. 
• L'esecuzione di un git commit a questo punto creerà un nuovo commit con le stesse modifiche di C

--misto

• Esegui git reset --mixed B. 
• All'esecuzione, master/HEAD punta a B e anche l'indice viene modificato per corrispondere a B a causa del flag misti utilizzato. 
• Se eseguiamo git commit a questo punto, non accadrà nulla poiché index corrisponde a HEAD.
• Abbiamo ancora i cambiamenti nella directory di lavoro, ma poiché non sono nell'indice, git status li mostra come nonstage. 
• Per eseguire il commit, git add e poi commit come al solito.

--difficile

• Esegui git reset --hard B
• All'esecuzione, master/HEAD punta a B e modifica la directory di lavoro
• Le modifiche aggiunte in C e tutte le modifiche non salvate saranno rimosse.
• I file nella copia di lavoro corrisponderanno al commit B, questo perderà in modo permanente tutte le modifiche apportate nel commit C più le modifiche non eseguite

Spero che questo confronto di flag disponibili per il comando git reset aiuti qualcuno a usarli saggiamente. Riferiscili per ulteriori dettagli link1 & link2

Il rebasing e il drop dei commit sono i migliori quando si desidera mantenere pulita la cronologia Utile quando si propongono patch a un ramo pubblico, ecc.

Se devi abbandonare il commit più in alto, il seguente one-liner aiuta

git rebase --onto HEAD~1 HEAD

Ma se vuoi eliminare uno dei tanti commit che hai detto

a -> b -> c -> d -> master

e vuoi rilasciare commit 'c'

git rebase --onto b c

Questo renderà "b" la nuova base di "d" eliminando "c"

Trova l'ultimo codice di hash di commit visualizzando il log per:

git log

Poi

git reset <the previous co>

Per completezza, darò un metodo evidentemente evidente che è stato trascurato dalle risposte precedenti.

Poiché il commit non è stato premuto, il telecomando è rimasto invariato, quindi:

1. Elimina il repository locale.
2. Clona il repository remoto.

Questo è talvolta necessario se il tuo fantastico cliente Git va via ciao. (es. errori non-fast-forward)

Non dimenticare di re-commit dei tuoi saved changes dall'ultimo Push.

Supponendo che tu stia lavorando in Visual Studio, se entri nella cronologia del tuo ramo e guardi tutti i tuoi commit, seleziona semplicemente l'evento prima del commit che vuoi annullare, fai clic con il tasto destro del mouse e seleziona Revert. Facile come quello.

Se vuoi eliminare i file sbagliati dovresti farlo 

git reset --soft <your_last_good_commit_hash_here>Qualora, se fai git status, vedrai i file nell'area di staging. È possibile selezionare i file errati e portarli verso il basso dall'area di gestione temporanea.

Mi piace il seguente.

git reset wrongFile1 wrongFile2 wrongFile3

Ora puoi semplicemente aggiungere i file che ti servono per Spingere,

git add goodFile1 goodFile2

impegnarli 

git commit -v o git commit -am "Message"

e spingere

git Push Origin master

Tuttavia, se non ti preoccupi dei file modificati, puoi resettare a fatica i precedenti buoni commit e inviare tutto al server.

di 

git reset --hard <your_last_good_commit_hash_here>

git Push Origin master

Se hai già pubblicato file errati sul server, puoi utilizzare il flag --force per inviare al server e modificare la cronologia.

git Push --force Origin master

Prova questo, hard reset al commit precedente in cui questi file non sono stati aggiunti, quindi:

git reset --hard <commit_hash>

Assicurati di avere un backup delle tue modifiche nel caso in cui sia un hard reset, il che significa che saranno perse (a meno che tu non abbiate nascosto in precedenza)

git reset --soft HEAD~1

Il ripristino riavvolgerà il ramo HEAD corrente alla revisione specificata. Note the --soft flag: questo assicura che le modifiche alle revisioni annullate siano preservate. Dopo aver eseguito il comando, troverai le modifiche come modifiche locali non vincolate nella tua copia di lavoro.

Se non vuoi mantenere queste modifiche, usa semplicemente il flag --hard. Assicurati di farlo solo quando sei sicuro di non aver più bisogno di queste modifiche.

 git reset --hard HEAD~1

Annullamento di più commit

git reset --hard 0ad5a7a6

tieni presente, tuttavia, che l'utilizzo del comando reset annulla tutti i commit successivi a quello a cui sei tornato:  

Quello che faccio ogni volta che ho bisogno di annullare un commit/commit sono:

1. git reset HEAD~<n> // il numero di ultimi commit che ho bisogno di annullare

2. git status // opzionale. Tutti i file sono ora in rosso (non inattivo).

3. Ora, posso aggiungere e commettere solo i file di cui ho bisogno:

   • git add <file names> & git commit -m "message" -m "details"
4. Facoltativo: posso ripristinare le modifiche dei file rimanenti, se necessario, alla loro condizione precedente, con checkout:
   • git checkout <filename>
5. se lo avessi già spinto all'origine remota, in precedenza:
   • git Push Origin <branch name> -f // usa -f per forzare la spinta.

Se si desidera annullare il primo commit nel repository

Incontrerai questo problema:

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

L'errore si verifica perché se l'ultimo commit è il commit iniziale (o nessun genitore) del repository, non c'è HEAD ~.

Soluzione

Se vuoi resettare l'unico commit sul ramo "master"

$ git update-ref -d HEAD
$ git rm --cached -r .

Ottieni l'ultimo ID di commit usando questo comando (nel log uno in alto è l'ultimo):

git log

Ottieni l'id di commit (GUID) ed esegui questo comando:

git revert <commit_id>

Come modificare un commit precedente

Generalmente non voglio annullare un gruppo di commit, ma piuttosto modificare un commit precedente su come vorrei averlo commesso in primo luogo.

Mi sono ritrovato a correggere un commit passato abbastanza frequentemente da aver scritto uno script per questo.

Ecco il flusso di lavoro:

1. git commit-edit <commit-hash>
   

   Questo ti lascerà al commit che vuoi modificare.

   I cambiamenti del commit saranno un stage, pronti per essere messi in scena come desideri fosse la prima volta.

2. Correggi e metti in scena il commit come desideri fosse stato in primo luogo.

   (Puoi usare git stash save --keep-index per eliminare tutti i file che non stai impegnando)

3. Ripristina il commit con --amend, ad esempio:

   git commit --amend
   

4. Completa il rebase:

   git rebase --continue
   

Chiamalo seguendo git-commit-edit e inseriscilo nel tuo $PATH:

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "[email protected]"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo

Se vuoi semplicemente cancellare tutte le tue modifiche/commit locali e rendere il tuo ramo locale simile al ramo Origin che hai iniziato da ...

git reset --hard Origin/branch-name

git revert commit

Questo genererà le modifiche opposte dal commit che si desidera ripristinare, e quindi solo commit di tali modifiche. Penso che questo sia il modo più semplice.

https://git-scm.com/docs/git-revert

sostituisci la tua versione locale incluse le tue modifiche con la versione del server, queste due linee di codice costringeranno git a tirare e sovrascrivere localmente. Apri il comando Prompt e vai alla root del progetto git. Se usi VS, clicca su Team, Sincronizza e clicca su "Apri prompt dei comandi" (vedi immagine) sotto. 

Una volta in Cmd Prompt, procedi con le seguenti due istruzioni. 

git fetch --all

allora lo fai

git reset --hard Origin/master

questo sovrascriverà la versione locale esistente con quella su git server

git Push --delete (branch_name) //this will be removing the public version of your branch

git Push Origin (branch_name) //This will add the previous version back