tornare Come annullare i commit più recenti in Git?




git tornare ad commit precedente (24)

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 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 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 log mostrerà che il nostro ultimo commit è stato rimosso.

Come annullare un commit pubblico

Se hai già reso pubblici i tuoi commit, ti consigliamo di 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 Git Basics - Annullare le cose

Ho erroneamente commesso i file errati su Git , ma non ho ancora inviato il commit al server.

Come posso annullare quei commit dal repository locale?


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 comando con --amend

git rm <pathToFile>

Puoi anche rimuovere intere directory con -r , o persino combinarle con altri comandi di 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 è consigliabile poiché sovrascrive la cronologia remota con una modifica divergente (può danneggiare il repository).

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


Utilizzare il reflog per trovare uno stato corretto

git reflog

REFLOG PRIMA DI RIPRISTINARE

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

git reset --hard f3cb6e2

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

Finalmente il reflog sembra l'immagine qui sotto

REFLOG FINALE


Basta resettarlo facendo il comando seguente usando git :

git reset --soft HEAD~1

Spiega: cosa fa git reset , in pratica è reset su qualsiasi commit a cui vorresti tornare, quindi se lo --soft a --soft key, tornerà indietro, ma manterrai le modifiche nei tuoi file, quindi 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:


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.


Annulla l'ultimo commit:

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

Questo annullerà l'ultimo commit.

Qui --soft significa reimposta in staging.

HEAD~ o HEAD^ significa spostare per commettere prima di HEAD.

Sostituisci ultimo commit con nuovo commit:

git commit --amend -m "message"

Sostituirà l'ultimo commit con il nuovo commit.


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


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 allo SHA-1 dell'hash se si desidera ripristinare. L' opzione --soft cancellerà il commit ma lascerà tutti i file modificati "Changes to be committed", come lo avrebbe dichiarato lo stato git.

Se si desidera eliminare eventuali modifiche ai file tracciati nell'albero di lavoro poiché il commit prima di testa 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 git revert ,

git revert HEAD

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


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


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 lascia invariato il tuo albero di lavoro (lo stato dei tuoi file su disco), ma annulla il commit e lascia le modifiche non commesse (quindi appariranno come "Cambiamenti non in scena per il commit" nello git status , e avrai bisogno di aggiungili di nuovo prima di eseguire il commit). Se vuoi solo aggiungere più modifiche al commit precedente, o cambiare il messaggio di commit 1 , puoi usare 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 vuoi includere nel tuo nuovo commit.
  5. Conferma le modifiche, riutilizzando il vecchio messaggio di commit. reset copia la vecchia testa in .git/ORIG_HEAD ; commit con -c ORIG_HEAD aprirà un editor, che inizialmente contiene il messaggio di log dal vecchio commit e ti permette di modificarlo. Se non è necessario modificare il messaggio, è possibile utilizzare l'opzione -C .

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

Se il codice è già stato inserito nel server e si dispone delle autorizzazioni per sovrascrivere la cronologia (rebase), procedere come segue:

git push origin master --force

Puoi anche guardare questa risposta:

Come spostare HEAD in una posizione precedente? (Testa staccata)

La risposta sopra mostrerà git reflog che viene usato per scoprire quale è lo SHA-1 al quale si desidera tornare. Una volta trovato il punto verso il quale si desidera annullare l'uso della sequenza di comandi come spiegato sopra.

1 Nota, tuttavia, che non è necessario ripristinare un commit precedente se hai appena commesso un errore nel tuo messaggio di commit . L'opzione più semplice è git reset (per mettere da parte le modifiche fatte da allora) e quindi git commit --amend , che aprirà l'editor dei messaggi di commit predefinito precompilato con l'ultimo messaggio di commit.


Utilizza git revert commit-id

Per ottenere l'ID commit, basta usare git log


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 l'impressionante rebase interattivo )

ProTip ™: aggiungi *.class a 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 viene reset una soluzione più generale.

Puoi ripristinare git con qualsiasi commit con:

git reset @~N

Dove N è il numero di commit prima di HEAD , e @~ ripristina il commit precedente.

Quindi, invece di modificare il commit, puoi usare:

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

--soft --mixed 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



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

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

Semplice, esegui questo nella tua riga di comando:

git reset --soft HEAD~ 

Un altro modo:

Esegui il checkout del ramo che vuoi ripristinare, quindi reimposta 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 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.


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>

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


Un singolo comando:

git reset --soft 'HEAD^' 

Funziona alla grande per annullare l'ultimo commit locale!


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 commit C e non vederlo mai più . Tu lo fai:

git reset --hard HEAD~1

Il risultato è:

 (F)
A-B
  ↑
master

Ora B è il TESTA. Perché hai usato --hard , i tuoi file sono resettati al 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 tuo HEAD:

   (F)
A-B-C
    ↑
  master

Puoi farlo, lasciando fuori il --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 git reset HEAD~1 un git reset HEAD~1 , dici a Git di spostare il puntatore HEAD indietro di un commit. Ma (a meno che tu non usi --hard ) tu lasci i tuoi file così com'erano. Quindi ora git status mostra le modifiche che hai controllato in C. Non hai perso nulla!

Per il tocco più leggero, puoi persino annullare il 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 solo il tuo indice . Quando git status , vedrai che gli stessi file si trovano nell'indice di prima. Infatti, subito dopo questo comando, potresti fare git commit e dovresti rifare lo stesso commit che hai appena fatto.

Un'altra cosa: supponi di distruggere un commit come nel primo esempio, ma poi scopri di averne bisogno dopo tutto ? Buona fortuna, giusto?

No, c'è ancora un modo per riaverlo. Digita git reflog e vedrai una lista di commit (parziali) 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.


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

git reset <the previous co>

Se vuoi rimuovere i file nell'ultimo commit, puoi usare questo:

git reset --hard HEAD~1

E se hai bisogno di file nell'ultimo commit, puoi usare questo:

git reset --soft HEAD~1

Come correggere il commit locale precedente

Usa git-gui (o simili) 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 successo. Per fare tutto ciò in un unico comando, usa git reset HEAD~1 .

Parola di avvertimento : l' uso git reset 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 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 invia il tuo ramo aggiornato al repository condiviso.

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

Avanzate: correzione del ramo privato nel repository pubblico

Questo 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 uno squash-merge per nascondere la cronologia.


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.





git-revert