Come faccio ad annullare l'ultima locali, si impegna in Git?

https://stackoverflow.com/questions/927358

06-09-2019
|

Domanda

Ho per sbaglio commesso il file errati per Git, ma non ho spinto il commit per il server di sicurezza.

Come posso annullare le commit dal repository locale?

Soluzione

Annulla un commit e rifare

$ 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)

Questo è ciò che si desidera annullare.
Questo lascia il vostro albero di lavoro (lo stato dei tuoi file su disco) invariato, ma annulla il commit e lascia le modifiche commesso Unstaged (così faranno appaiono come "Le modifiche non messo in scena per impegnarsi" in git status, quindi dovrete necessario aggiungere di nuovo prima di commettere). Se solo vogliono Aggiungi più modifiche al precedente commit, o modificare il messaggio di commit ¹, è possibile utilizzare git reset --soft HEAD~ invece, che è come git reset HEAD~ (dove HEAD~ è lo stesso di HEAD~1) ma lascia le modifiche esistenti in scena.
Correggi a lavorare file di alberi.
git add tutto ciò che si desidera includere nel nuovo commit.
commit delle modifiche, riutilizzando il vecchio messaggio di commit. reset copiato la vecchia testa a .git/ORIG_HEAD; commit con -c ORIG_HEAD si 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.

Attenzione però che se avete aggiunto nuove modifiche al indice, utilizzando commit --amend li aggiungerà al vostro commit precedente.

Se il codice è già spinto al server e si dispone delle autorizzazioni per sovrascrivere la storia (rebase) poi:

git push origin master --force

Si può anche guardare a questa risposta:

come muoversi tornare a una posizione precedente? (Testa indipendente) e Annulla impegna

La risposta di cui sopra vi mostrerà git reflog che viene utilizzato per scoprire che cosa è l'SHA-1 che si desidera ripristinare. Una volta trovato il punto in cui si desidera annullare per utilizzare la sequenza di comandi come spiegato sopra.

¹ Si noti, tuttavia, che non è necessario per ripristinare una precedente impegnarsi se hai appena fatto un errore nel messaggio commit . L'opzione più semplice è quella di git reset (a unstage eventuali modifiche apportate dal momento) e poi git commit --amend , che aprirà predefinito commit editor di messaggi pre-popolato con l'ultimo messaggio di commit.

Altri suggerimenti

L'annullamento di un commit è un po 'paura, se non si sa come funziona. Ma in realtà è incredibilmente facile se si capisce.

Dire che hai questo, dove C è la testa e (F) è lo stato dei file.

   (F)
A-B-C
    ↑
  master

Si desidera Nuke commettere C e mai vedere di nuovo . A tale scopo:

git reset --hard HEAD~1

Il risultato è:

 (F)
A-B
  ↑
master

Ora B è il capo. Perché hai usato --hard, i file vengono ripristinati al loro stato a commettere B.

Ah, ma supponiamo commettere C non è stato un disastro, ma solo un po 'fuori. Si desidera annullare l'impegno, ma mantenere le modifiche per un po 'di editing prima di fare una migliore commettere. Ripartire da qui, con C come HEAD:

   (F)
A-B-C
    ↑
  master

È possibile 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 si esegue un git reset HEAD~1, dite Git per spostare il puntatore del HEAD indietro di un commit. Ma (a meno che non si utilizza --hard) si lascia i file come erano. Così ora git status mostra i cambiamenti che aveva controllato in C. Non hanno perso nulla!

Per il tocco più leggero, si può anche annullare l'commettere ma lasciare i tuoi file e il tuo index :

git reset --soft HEAD~1

Questo non solo lascia i file da solo, lascia anche il tuo index solo. Quando si esegue git status, vedrai che gli stessi file sono nell'indice come prima. Infatti, subito dopo questo comando, si potrebbe fare git commit e si sarebbe rifare la stessa commit si è appena conclusa.

Ancora una cosa: Si supponga di distruggere un commit , come nel primo esempio, ma poi scoprire avevi bisogno dopo tutto ? Che sfortuna, vero?

No, non c'è ancora un modo per tornare indietro. Digitare git reflog e vedrete una lista di (parziale) commettere Shas (che è, hash) che hai spostato in giro per Trova il commit hai distrutto, e fare questo:.

git checkout -b someNewBranchName shaYouDestroyed

Ora hai resuscitato che commettono. Impegna in realtà non vengono distrutti in Git per circa 90 giorni, quindi di solito si può tornare indietro e salvare quello che non avevo intenzione di sbarazzarsi di.

Questo mi ha portato un po 'per capire, quindi forse questo aiuterà qualcuno ...

Ci sono due modi per "annullare" la vostra ultima commettere, a seconda se o non avete già fatto la vostra commettere pubbliche (spinto al repository remoto):

Per annullare un locale di commit

Diciamo che ho commesso a livello locale, 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 indietro al modo in cui era prima dell'ultimo commit, abbiamo bisogno di reset per il commit prima 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 la nostra ultima commit è stato rimosso.

Per annullare un pubblico impegnano

Se avete già fatto la vostra pubblico commit, si vuole creare un nuovo commit che "ripristinare" le modifiche apportate nel vostro commit precedente (attuale capo).

git revert HEAD

Le modifiche verranno annullate e pronto per impegnarsi:

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

Per ulteriori informazioni, consulta Git Basics - Cose Annullamento

Aggiungi / rimuovere i file per ottenere le cose nel modo desiderato:

git rm classdir
git add sourcedir

Quindi modificare il commit:

git commit --amend

Il precedente, erronea commit verrà modificato in modo da riflettere il nuovo stato di indice -. In altre parole, sarà come non hai mai fatto l'errore in primo luogo

Si noti che si dovrebbe fare solo se non si è ancora spinto. Se è stato spinto, allora non vi resta che commettere una correzione normalmente.

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

git reset --hard HEAD~1

Attenzione:. Il comando sopra rimuoverà in modo permanente le modifiche ai file .java (e qualsiasi altro file) che si volesse impegnarsi

Il hard reset per HEAD-1 imposterà la vostra copia di lavoro per lo stato del commit prima sbagliato commesso.

Per modificare gli ultimi commettere

Sostituire 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

In alternativa, se si tratta di un ramo condiviso, fare un nuovo impegno:

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

( per cambiare un commit precedente , utilizzare il rebase interattivo )

PROTIP ™: Aggiungi *.class a una gitignore per fermare questo accada di nuovo

Per ripristinare un commit

La modifica un commit è la soluzione ideale se avete bisogno di cambiare all'ultimo commit, ma una soluzione più generale è reset.

È possibile ripristinare git a qualsiasi commettere con:

git reset @~N

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

Così, invece di modificare il commit, è possibile utilizzare:

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

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

reflog

Se si fa confusione, si può sempre utilizzare il reflog per trovare commit cadute:

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

Usa git revert <commit-id>

Per ottenere l'ID commit, basta usare git log

Se avete intenzione di annullare un locale di impegnarsi totalmente, tutto ciò che hai fatto cambiare il commit, e se non ti preoccupare nulla, basta fare il seguente comando.

git reset --hard HEAD^1

(Questo comando ignorerà l'intero commit e le modifiche andranno perse completamente dal vostro albero di lavoro locale). Se si vuole annullare l'impegno, ma si desidera che le variazioni dell'area di sosta (prima di impegnarsi come dopo git add) quindi effettuare il seguente comando.

git reset --soft HEAD^1

Ora i file impegnati entrano in area di sosta. Supponiamo che se si vuole eclissare i file, perché è necessario modificare alcuni contenuti sbagliato, quindi effettuare il seguente comando

git reset HEAD

Ora i file impegnati a venire dalla zona in scena nella zona non è stato classificato. Ora i file sono pronti a modificare, per cui qualunque cosa si cambia, vuoi andare modificare e aggiunto e fare un fresco / nuovo commit.

Altro

Se hai Git Extra installato, è possibile eseguire git undo per annullare l'ultima commit. git undo 3 annullerà le ultime 3 commit.

Ho voluto annullare la più recente 5 commit nel nostro repository condiviso. Ho guardato l'id di revisione che ho voluto rollback a. Poi ho digitato in seguito.

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>

Io preferisco usare git rebase -i per questo lavoro, perché una bella lista si apre dove posso scegliere i commit per sbarazzarsi di. Potrebbe non essere così diretta come alcune altre risposte qui, ma solo ritiene di destra .

Scegli il numero di commit si desidera elencare, quindi richiamare in questo modo (ad arruolarsi ultimi tre)

git rebase -i HEAD~3

La lista del campione

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

Poi Git rimuoverà commit per tutte le linee di rimuovere.

Come risolvere il precedente commit locale

Utilizzare git-gui (o simili) per eseguire un git commit --amend.Dall'interfaccia è possibile aggiungere o rimuovere singoli file da commettere.È inoltre possibile modificare il messaggio di commit.

Come annullare il precedente commit locale

Basta reimpostare la propria filiale la posizione precedente (per esempio, l'utilizzo di gitk o git rebase).Quindi riapplicare le modifiche da una copia salvata.Dopo la raccolta rifiuti in tuo repository locale, sarà come indesiderato commettere mai successo.Per fare tutto questo in un unico comando, utilizzare git reset HEAD~1.

Parola di avvertimento: Uso incauto di git reset è un buon modo per ottenere la vostra copia di lavoro in uno stato di confusione.Mi raccomando che la Git novizi evitarlo, se possibile.

Come annullare un pubblico di commit

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

Se non hai ancora tirato le altre modifiche sul tuo ramo, si può semplicemente fare...

git revert --no-edit HEAD

Poi spingere la vostra aggiornati ramo per il repository condiviso.

Il commit storia mostrerà entrambi si impegna, separatamente.

Avanzate:Correzione del privato succursale in un repository pubblico

Questo può essere pericoloso, essere sicuri di avere una copia locale del ramo di repush.

Anche di nota:Non si vuole fare questo se qualcun altro potrebbe essere al lavoro su un ramo.

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

Pulire il vostro ramo locale quindi repush...

git push origin (branch_name)

In un caso normale, probabilmente non c'è bisogno di preoccuparsi per la vostra privato-filiale di impegnare la storia che può essere incontaminata.Basta premere un follow-up di commit (vedere 'Come annullare un pubblico commit' sopra), e poi, fare un squash-unione per nascondere la storia.

Se avete commesso spazzatura, ma non spinto,

git reset --soft HEAD~1

HEAD ~ 1 è una scorciatoia per il commit prima di testa. In alternativa, è possibile fare riferimento al SHA-1 del hash, se si vuole ripristinare. -. Morbido cancellerà il commit ma lascerà tutti i file modificati "Modifiche da impegnare", come git status direbbe

Se si vuole sbarazzarsi di eventuali modifiche ai file rilevate nella struttura di lavoro in quanto il commit prima dell'uso testa " - difficile ". Invece

Se si è già spinto e qualcuno tirato che di solito è il mio caso, non è possibile utilizzare Ripristino git . È possibile tuttavia fare un git revert ,

git revert HEAD

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

Se si desidera annullare in modo permanente e si è clonato alcuni repository

L'id commettere può essere visto da

git log

Poi si può fare -

git reset --hard <commit_id>

git push origin <branch_name> -f

SourceTree (GUI per GitHub), è possibile fare clic con il commit e fare un 'Reverse Commit '. Questo dovrebbe annullare le modifiche.

Sul terminale:

È possibile in alternativa utilizzare:

git revert

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 unico comando:

git reset --soft 'HEAD^'

E le grandi opere per annullare commettere l'ultimo locale!

Basta azzerare ci fa il comando di seguito utilizzando git:

git reset --soft HEAD~1

Spiegare: che cosa git reset fa, è fondamentalmente reset a qualsiasi commettere vuoi tornare a, quindi se si combinano con la chiave --soft, andrà indietro, ma mantenere le modifiche in il file (s), in modo da ottenere di nuovo sul palco, che il file è stato appena aggiunto, HEAD è il capo del ramo e se si combinano con ~1 (in questo caso si usa anche HEAD^), si torna solo un commit che ciò che si vuole ...

creo la procedura nella immagine qui sotto in maggior dettaglio per voi, tra cui tutti i passaggi che possono accade in situazioni reali e commettendo il codice:

Come annullare l'ultima git commit?

Per ripristinare tutto indietro al modo in cui era prima dell'ultimo commit, abbiamo bisogno di ripristinare il commit prima che la testa.

Se non si desidera mantenere le modifiche apportate:
```
git reset --hard HEAD^
```
Se si desidera mantenere le modifiche:
```
git reset --soft HEAD^
```

Ora controllare il git log. Mostrerà che la nostra ultima commit è stato rimosso.

Usa reflog per trovare uno stato corretto

git reflog

reflog PRIMA DI RESET

Selezionare il reflog corretta (f3cb6e2 nel mio caso) e digitare

git reset --hard f3cb6e2

Dopo che il capo di pronti contro termine sarà ripristinato a quello HEADid effetto reset LOG dopo il reset

Infine, il reflog appare come l'immagine qui sotto

reflog dopo reflog FINALE

"Ripristina l'albero di lavoro fino all'ultimo commit"

git reset --hard HEAD^

"Clean file sconosciuti da un albero di lavoro"

git clean

vedere - Git di riferimento rapido

Nota: Questo comando eliminare la precedente commettere, in modo da utilizzare con cautela! git reset --hard è più sicuro -

Prima esecuzione:

git reflog

Vi mostrerà tutte le possibili azioni eseguite su repository, per esempio, commettere, unire, tirare, ecc.

Quindi fare:

git reset --hard ActionIdFromRefLog

Annulla l'ultima commit:

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

In questo modo annullare l'ultima commit.

Qui --soft significa azzeramento nella messa in scena.

HEAD~ o HEAD^ mezzi per spostarsi a commettere prima di HEAD.

Sostituire ultima impegnano a nuove commettere:

git commit --amend -m "message"

Si andrà a sostituire l'ultimo commit con il nuovo commit.

Un altro modo:

checkout il ramo che si desidera ripristinare, quindi reimpostare la copia di lavoro locale al commettere che si desidera essere quello più recente sul server remoto (tutto quello che segue andrà bye-bye). Per fare questo, in SourceTree right-cliccato sul e selezionato "Reset branchname a questo commit".

Quindi passare 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 attuale nel repository locale, ma solo per quella ramo.

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

git reset <the previous co>

Nel mio caso ho commesso accidentalmente alcuni file non volevo. Così ho fatto la seguente 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 dei risultati con gitk o git log --stat

Semplice, eseguire questo nella riga di comando:

git reset --soft HEAD~

Ci sono molti modi per farlo:

comando Git per annullare l'ultima commit / commit precedenti:

Attenzione: Non utilizzare --hard se non si sa cosa si sta facendo. --hard è troppo pericoloso , e potrebbe eliminare i file.

Comando di base per ripristinare il commit in Git è:

$ git reset --hard <COMMIT -ID>

$ git reset --hard HEAD~<n>

commit-ID : ID per il commit

n: è il numero di ultima impegna si desidera ripristinare

È possibile ottenere il commit id come illustrato 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 commettere id.

Ora vediamo alcuni casi:

Si supponga di voler ripristinare l'ultimo commit 'd81d3f1'. Qui ci sono due opzioni:

$ git reset --hard d81d3f1

$ git reset --hard HEAD~1

Si supponga di voler ripristinare il commit 'be20eb8':

$ git reset --hard be20eb8

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

$ git reset --help

Per ripristinare la precedente revisione, cancellando in modo permanente tutte le modifiche non salvate:

git reset --hard HEAD~1

SourceTree (strumento grafico per Git) per vedere i vostri commit e albero. È possibile reimpostare manualmente direttamente facendo clic destro di esso.

Per un locale di commit

git reset --soft HEAD~1

o se non si ricorda esattamente che impegnano lo è, si potrebbe utilizzare

git rm --cached <file>

Per un spinto commit

Il modo corretto di rimozione dei file dalla storia repository sta usando git filter-branch. Cioè,

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

Ma io recomnend si utilizza questo comando con cura. Per saperne di più a git-filtro-ramo (1) Manuale .

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow