modifiche - git tornare ad commit precedente




Come annullare i commit più recenti in Git? (20)

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.

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?


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.


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.


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


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.


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:


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 ripristinare il commit in Git è:

$ git reset --hard <COMMIT -ID>

o

$ git reset --hard HEAD~<n>

COMMIT-ID : ID per il commit

n: è il numero degli ultimi commit che vuoi annullare

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

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 ad uno stato specificato:

$ git reset --help

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


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.


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.


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


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

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

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


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


Utilizza git revert commit-id

Per ottenere l'ID commit, basta usare git log


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>

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