it-swarm.it

Come ripristinare un repository Git su un commit precedente

Come faccio a tornare dal mio stato attuale a uno scatto fatto su un certo commit?

Se faccio git log, ottengo il seguente risultato:

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <[email protected]>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <[email protected]>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <[email protected]>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <[email protected]>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

Come ripristinare il commit dal 3 novembre, ovvero commit 0d1d7fc?

6795
Crazy Serb

Questo dipende molto da cosa intendi per "ripristinare".

Passa temporaneamente a un commit diverso

Se vuoi tornare temporaneamente su di esso, giocare, poi tornare dove sei, tutto quello che devi fare è dare un'occhiata al commit desiderato:

# This will detach your HEAD, that is, leave you with no branch checked out:
git checkout 0d1d7fc32

O se vuoi fare dei commit mentre sei lì, vai avanti e crea un nuovo ramo mentre ci sei:

git checkout -b old-state 0d1d7fc32

Per tornare al punto in cui ti trovavi, controlla il ramo su cui eri di nuovo. (Se hai apportato delle modifiche, come sempre quando cambi succursali, dovrai gestirle a seconda dei casi.Potresti reimpostarle per buttarle via, potresti mettere da parte, chiudere, ripulire pop per portarle con te, potresti commettere li a un ramo lì se vuoi un ramo lì.)

Elimina duramente commit non pubblicati

Se, d'altra parte, vuoi veramente sbarazzarti di tutto ciò che hai fatto da allora, ci sono due possibilità. Uno, se non hai pubblicato nessuno di questi commit, resetta semplicemente:

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

Se incasini, hai già buttato via le tue modifiche locali, ma puoi almeno tornare al punto in cui ti trovavi prima reimpostando di nuovo.

Annulla i commit pubblicati con nuovi commit

D'altra parte, se hai pubblicato il lavoro, probabilmente non vuoi reimpostare il ramo, dal momento che è effettivamente riscrivere la cronologia. In tal caso, è possibile ripristinare i commit. Con Git, il ripristino ha un significato molto specifico: crea un commit con la patch inversa per cancellarlo. In questo modo non riscrivi alcuna cronologia.

# This will create three separate revert commits:
git revert a867b4af 25eee4ca 0766c053

# It also takes ranges. This will revert the last two commits:
git revert HEAD~2..HEAD

#Similarly, you can revert a range of commits using commit hashes:
git revert a867b4af..0766c053 

# Reverting a merge commit
git revert -m 1 <merge_commit_sha>

# To get just one, you could use `rebase -i` to squash them afterwards
# Or, you could do it manually (be sure to do this at top level of the repo)
# get your index and work tree into the desired state, without changing HEAD:
git checkout 0d1d7fc32 .

# Then commit. Be sure and write a good message describing what you just did
git commit

La manpage git-revert in realtà copre molto di questo nella sua descrizione. Un altro link utile è questa sezione git-scm.com che discute di git-revert .

Se decidi di non voler tornare indietro, puoi ripristinare il ripristino (come descritto qui) o ripristinare prima del ripristino (vedi la sezione precedente).

Potresti trovare questa risposta utile anche in questo caso:
Come spostare HEAD in una posizione precedente? (Testa staccata)

8690
Cascabel

Ripristino della copia di lavoro in commit più recente

Per ripristinare un commit precedente, ignorando eventuali modifiche:

git reset --hard HEAD

dove HEAD è l'ultimo commit nel tuo ramo attuale

Ripristino della copia di lavoro in un commit precedente

Per ripristinare un commit più vecchio del commit più recente:

# Resets index to former commit; replace '56e05fced' with your commit code
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft [email protected]{1}

git commit -m "Revert to 56e05fced"

# Updates working copy to reflect the new commit
git reset --hard

I crediti vanno a una domanda simile di Stack Overflow,Ripristina un commit da un SHA hash in Git?.

1451
boulder_ruby

Molte risposte complicate e pericolose qui, ma in realtà è facile:

git revert --no-commit 0766c053..HEAD
git commit

Questo ripristinerà tutto dal HEAD all'hash del commit, il che significa che ricrea lo stato di commit nell'albero di lavoro come se ogni commit da quando è stato riportato indietro. Puoi quindi commettere l'albero corrente e creerà un nuovo commit essenzialmente equivalente al commit "ripristinato".

(Il flag --no-commit consente a git di annullare tutti i commit in una volta, altrimenti ti verrà richiesto un messaggio per ogni commit nell'intervallo, sporcando la tua cronologia con nuovi commit non necessari.)

Questo è un modo semplice e sicuro per ripristinare uno stato precedente . Nessuna storia viene distrutta, quindi può essere utilizzata per i commit che sono già stati resi pubblici.

1433
Yarin

L'opzione migliore per me e probabilmente per altri è l'opzione di ripristino Git:

git reset --hard <commidId> && git clean -f

Questa è stata l'opzione migliore per me! È semplice, veloce ed efficace!


Nota: Come menzionato nei commenti, non farlo se condividi il tuo ramo con altre persone che hanno copie dei vecchi commit

Anche dai commenti, se volevi un metodo meno "ballzy" che potresti usare

git clean -i

182
Pogrindis

Prima di rispondere aggiungiamo un po 'di background, spiegando che cos'è questo HEAD.

First of all what is HEAD?

HEAD è semplicemente un riferimento al commit corrente (più recente) sul ramo corrente. Può esistere un solo HEAD in qualsiasi momento (escluso git worktree).

Il contenuto di HEAD è memorizzato all'interno di .git/HEAD e contiene i 40 byte SHA-1 del commit corrente.


detached HEAD

Se non sei sull'ultimo commit - significa che HEAD sta puntando a un commit precedente nella cronologia è chiamatodetached HEAD.

 Enter image description here

Sulla riga di comando sarà simile a questo: SHA-1 invece del nome del ramo poiché HEAD non punta alla punta del ramo corrente:

 Enter image description here


Alcune opzioni su come recuperare da un HEAD distaccato:


git checkout

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits t go back

Questo controllerà il nuovo ramo che punta al commit desiderato. Questo comando eseguirà il checkout su un dato commit.

A questo punto puoi creare un ramo e iniziare a lavorare da questo punto in poi:

# Checkout a given commit.
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# Create a new branch forked to the given commit
git checkout -b <branch name>

git reflog

Puoi sempre usare anche reflog. git reflog mostrerà ogni cambiamento che ha aggiornato HEAD e verificando la voce di reflog desiderata imposterà HEAD a questo commit.

Ogni volta che HEAD viene modificato ci sarà una nuova voce in reflog

git reflog
git checkout [email protected]{...}

Questo ti riporterà al commit desiderato

 Enter image description here


git reset HEAD --hard <commit_id>

"Sposta" la testa indietro al commit desiderato.

# 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, reset && checkout modifica HEAD.

 Enter image description here

143
CodeWizard

Se vuoi "uncommit", cancella l'ultimo messaggio di commit e rimetti i file modificati nella staging, dovresti usare il comando:

git reset --soft HEAD~1
  • --soft indica che i file non salvati devono essere mantenuti come file di lavoro opposti a --hard che li eliminerebbe.
  • HEAD~1 è l'ultimo commit. Se si desidera eseguire il rollback di 3 commit, è possibile utilizzare HEAD~3. Se si desidera eseguire il rollback su un numero di revisione specifico, è possibile farlo utilizzando il suo SHA hash.

Questo è un comando estremamente utile in situazioni in cui hai commesso la cosa sbagliata e vuoi annullare quell'ultimo commit.

Fonte: http://nakkaya.com/2009/09/24/git-delete-last-commit/

124

Ho provato un sacco di modi per ripristinare le modifiche locali in Git e sembra che funzioni meglio se si desidera ripristinare lo stato di commit più recente.

git add . && git checkout master -f

Breve descrizione:

  • NON creerà alcun commit come fa git revert.
  • NON scollega il tuo HEAD come fa git checkout <commithashcode>.
  • Sostituirà tutte le modifiche locali e CANCELLERÀ tutti i file aggiunti dall'ultimo commit nel ramo.
  • Funziona solo con i nomi dei rami, quindi puoi ripristinare solo l'ultimo commit nel ramo in questo modo.

Ho trovato un modo molto più conveniente e semplice per ottenere i risultati sopra:

git add . && git reset --hard HEAD

dove HEAD punta all'ultima commit al tuo attuale ramo.

È lo stesso codice codice suggerito da boulder_Ruby, ma ho aggiunto git add . prima git reset --hard HEAD per cancellare tutti i nuovi file creati dall'ultimo commit poiché questo è ciò che la maggior parte delle persone si aspetta che io creda quando si ripristina l'ultimo commit.

105
Roman Minenok

Puoi farlo con i seguenti due comandi:

git reset --hard [previous Commit SHA id here]
git Push Origin [branch Name] -f

Rimuoverà il tuo precedente commit Git.

Se vuoi mantenere le tue modifiche, puoi anche usare:

git reset --soft [previous Commit SHA id here]

Quindi salverà le tue modifiche.

94
kiran boghra

OK, tornare al commit precedente in git è abbastanza facile ...

Ripristina senza mantenere le modifiche:

git reset --hard <commit>

Ripristina mantenendo le modifiche:

git reset --soft <commit>

Spiega: usando git reset, puoi resettare ad uno stato specifico, è normale usarlo con un hash di commit come vedi sopra.

Ma come vedi la differenza sta usando i due flag --soft e --hard, di default git reset usando --soft flag, ma è una buona pratica usare sempre la flag, spiego ogni flag:


--soft

Il flag predefinito come spiegato, non è necessario fornirlo, non modifica l'albero di lavoro ma aggiunge tutti i file di modifiche pronti per il commit, quindi si torna allo stato di commit che non viene disattivato.


--difficile

Fai attenzione a questo flag, resetta l'albero di lavoro e tutte le modifiche ai file tracciati e tutto sarà sparito!


Ho anche creato l'immagine qui sotto che può accadere in una vita reale lavorando con git:

 git reset to a commit

63
Alireza

Niente qui ha funzionato per me oltre a questa combinazione esatta:

git reset --hard <commit_hash>
git Push Origin <branch_name> --force

La chiave qui sta forzando la Spinta, nessun extra commette/commette messaggi ecc.

59
serdarsenay

Supponiamo che tu abbia il seguente commit in un file di testo chiamato ~/commits-to-revert.txt (ho usato git log --pretty=oneline per ottenerli)

fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
0c27ecfdab3cbb08a448659aa61764ad80533a1b
f85007f35a23a7f29fa14b3b47c8b2ef3803d542
e9ec660ba9c06317888f901e3a5ad833d4963283
6a80768d44ccc2107ce410c4e28c7147b382cd8f
9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
fff2336bf8690fbfb2b4890a96549dc58bf548a5
1f7082f3f52880cb49bc37c40531fc478823b4f5
e9b317d36a9d1db88bd34831a32de327244df36a
f6ea0e7208cf22fba17952fb162a01afb26de806
137a681351037a2204f088a8d8f0db6e1f9179ca

Crea uno script Bash Shell per annullare ciascuno di essi:

#!/bin/bash
cd /path/to/working/copy
for i in `cat ~/commits-to-revert.txt`
do
    git revert $i --no-commit
done

Ciò ripristina tutto allo stato precedente, incluse le creazioni di file e directory e le eliminazioni, lo trasferiscono al ramo e conservano la cronologia, ma vengono ripristinate nella stessa struttura di file. Perché Git non ha un git revert --to <hash> è oltre me.

57
Lance Caraccioli

Ulteriori alternative alle soluzioni di Jefromi

Le soluzioni di Jefromi sono decisamente le migliori, e dovresti sicuramente usarle. Tuttavia, per completezza, volevo anche mostrare queste altre soluzioni alternative che possono essere utilizzate anche per ripristinare un commit (nel senso che tu crea un nuovo commit che annulla le modifiche nel commit precedente , solo come fa git revert).

Per essere chiari, queste alternativenon sono il modo migliore per ripristinare i commit, Le soluzioni di Jefromi sono , ma voglio solo sottolineare che puoi usare anche questi altri metodi per ottenere la stessa cosa di git revert.

Alternativa 1: reset hard e soft

Questa è una versione leggermente modificata della soluzione di Charles Bailey per Ripristina un commit da un SHA hash in Git? :

# Reset the index to the desired commit
git reset --hard <commit>

# Move the branch pointer back to the previous HEAD
git reset --soft [email protected]{1}

# Commit the changes
git commit -m "Revert to <commit>"

Questo funziona fondamentalmente usando il fatto che le reimpostazioni software lasceranno lo stato del commit precedente messo a punto nell'indice/area di staging, che è quindi possibile eseguire il commit.

Alternativa 2: Elimina l'albero corrente e sostituisci con quello nuovo

Questa soluzione viene dalla soluzione di svick a Checkout vecchio commit e rendilo un nuovo commit :

git rm -r .
git checkout <commit> .
git commit

Analogamente all'alternativa # 1, questo riproduce lo stato di <commit> nella copia di lavoro corrente. È necessario prima eseguire git rm perché git checkout non rimuoverà i file che sono stati aggiunti da <commit>.

56
user456814

Supponendo che tu stia parlando di master e di quel rispettivo ramo (detto questo, potrebbe trattarsi di qualsiasi ramo di lavoro di cui ti occupi):

# Reset local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

# Reset remote master branch to November 3rd commit ID
git Push -f Origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master

Ho trovato la risposta da un post sul blog (ora non esiste più)

Nota che questo è il reset e forzatura della modifica al telecomando, in modo che se altri membri della tua squadra hanno già tirato git, causeranno problemi per loro. Stai distruggendo la cronologia dei cambiamenti, che è una ragione importante per cui le persone usano git in primo luogo.

Meglio usare il ripristino (vedi altre risposte) di resettare. Se sei una squadra di un solo uomo, allora probabilmente non importa.

55
markreyes

Ecco un molto più semplice modo per tornare a un commit precedente (e averlo in uno stato non limitato, per fare ciò che vuoi):

git reset HEAD~1

Quindi, non c'è bisogno di ID commit e così via :)

51
Paul Walczewski

Dopo tutte le modifiche, quando si spingono tutti questi comandi, potrebbe essere necessario utilizzare:

git Push -f ...

E non solo git Push.

34
sivi

Esiste un comando (non una parte del core Git, ma è nel pacchetto git-extras specificamente per il ripristino e la stadiazione dei vecchi commit:

git back

Per man page , può anche essere usato come tale:

# Remove the latest three commits
git back 3
33
Shadow Man

È possibile completare personalmente tutti questi passaggi iniziali e tornare a git repo.

  1. Estrai l'ultima versione del tuo repository da Bitbucket usando il comando git pull --all.

  2. Esegui il comando git log con -n 4 dal tuo terminale. Il numero dopo -n determina il numero di commit nel registro a partire dal commit più recente nella cronologia locale.

    $ git log -n 4

  3. Reimposta la cronologia della cronologia del tuo repository usando git reset --hard HEAD~N dove N è il numero di commit che vuoi recuperare. Nell'esempio seguente, la testa dovrebbe essere impostata su un commit, sull'ultimo commit nella cronologia del repository:

  4. Spingere la modifica a git repo utilizzando git Push --force per forzare Spingere la modifica.

Se vuoi git repository ad un commit precedente

git pull --all
git reset --hard HEAD~1
git Push --force
29
Nanhe Kumar

Ritorna a più recente commit e ignorando tutte le modifiche locali:

git reset --hard HEAD

Seleziona il commit richiesto e controllalo

git show HEAD
git show HEAD~1
git show HEAD~2 

fino a ottenere il commit richiesto. Per fare in modo che HEADpunti a questo, fallo

git reset --hard HEAD~1

o git reset --hard HEAD~2 o altro.

26
tonythomas01

Questo è un altro modo per reimpostare direttamente su un commit recente

git stash
git stash clear

Cancella direttamente tutte le modifiche che sono state apportate dall'ultimo commit.

PS: ha un piccolo problema; cancella anche tutte le modifiche di stash memorizzate di recente. Quale suppongo nella maggior parte dei casi non dovrebbe importare.

20
Point Networks

Per mantenere le modifiche dal commit precedente a HEAD e passare al commit precedente, fai:

git reset <SHA>

Se non sono richieste modifiche dal commit precedente a HEAD e semplicemente scartare tutte le modifiche, fare:

git reset --hard <SHA>
20
Vishnu Atrai

Per pulire completamente la directory di un codificatore da alcune modifiche accidentali, abbiamo utilizzato:

git add -A .
git reset --hard HEAD

Solo git reset --hard HEAD eliminerà le modifiche, ma non eliminerà i "nuovi" file. Nel loro caso avevano trascinato accidentalmente una cartella importante in un posto casuale, e tutti quei file venivano trattati come nuovi da Git, quindi un reset --hard non lo aggiustava. Eseguendo in anticipo git add -A ., ha tracciato esplicitamente tutti loro con git, per essere cancellati dal reset.

20
Chris Moschini

Credo che alcune persone possano venire a questa domanda volendo sapere come eseguire il rollback delle modifiche apportate che hanno apportato al loro master, cioè buttare via tutto e tornare a Origin/master, nel qual caso, fare questo:

git reset --hard Origin/master

https://superuser.com/questions/273172/how-to-reset-master-to-Origin-master

19
nevster

Revert è il comando per il rollback dei commit.

git revert <commit1> <commit2> 

Campione:

git revert 2h3h23233

È in grado di prendere distanza dal HEAD come di seguito. Qui 1 dice "ripristina l'ultimo commit".

git revert HEAD~1..HEAD

e poi fai git Push

16

Ripristina commit più recente:

git reset --hard HEAD

HEAD è semplicemente un riferimento al commit corrente (più recente) sul ramo corrente. Può esistere un solo HEAD in qualsiasi momento.

Ripristina un vecchio commit: il modo più veloce per ripristinare una vecchia versione è utilizzare il comando reset:

# Resets index to former commit
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft [email protected]{1}

# Updates working copy to reflect the new commit
git reset --hard

Questo riavvolgerà il tuo ramo HEAD alla versione specificata. Tutti i commit che sono arrivati ​​dopo questa versione sono effettivamente annullati; il tuo progetto è esattamente come era in quel momento.

Il comando reset include un paio di opzioni, una delle più interessanti è il flag --soft. Se lo usi invece di --hard, Git manterrà tutte le modifiche in quei commit "annullati" come modifiche locali.

Ripristino di una revisione in a Nuovo ramo locale

Come detto, l'utilizzo del comando reset sul ramo HEAD è un'azione abbastanza drastica: rimuoverà qualsiasi commit (su questo ramo) che è venuto dopo la revisione specificata. Se sei sicuro che questo è ciò che vuoi, va tutto bene.

Tuttavia, esiste anche un safe way nel caso in cui preferisci lasciare intatto il tuo attuale HEAD branch. Poiché "rami" sono così economici e facili in Git, possiamo facilmente creare un nuovo ramo che inizia con quella vecchia revisione:

git checkout -b old-project-state 0ad5a7a6

Normalmente, il comando checkout viene usato per cambiare ramo. Tuttavia, fornendo il parametro -b, è anche possibile lasciarlo creare un nuovo ramo (denominato old-project-state in questo esempio). Se non vuoi che inizi con la revisione HEAD corrente, devi anche fornire un hash di commit, la vecchia revisione del progetto che vogliamo ripristinare.

Ora hai un nuovo ramo chiamato old-project-state che riflette la vecchia versione del tuo progetto - senza toccare o rimuovere alcun altro commit o ramo.

16
Lyes CHIOUKH

Se la situazione è un urgente , e vuoi solo fare ciò che l'interrogante ha chiesto in a quick and dirty way, assumendo che il tuo progetto sia nella directory "my project":

  1. Copia l'intera directory e chiamala qualcos'altro, come "il mio progetto - copia"

  2. Fare:

    git reset --hard [first-4-letters&numbers-of-commit's-SHA]
    

Quindi hai due versioni sul tuo sistema ... puoi esaminare o copiare o modificare i file di interesse, o qualsiasi altra cosa, dal commit precedente. Puoi scartare completamente i file sotto "il mio progetto - copia", se hai deciso che il nuovo lavoro non andava da nessuna parte ...

La cosa ovvia se si vuole portare avanti lo stato del progetto senza effettivamente scartare il lavoro dal momento che questo impegno recuperato è di rinominare nuovamente la directory: Cancellare il progetto contenente il commit recuperato (o dargli un nome temporaneo) e rinominare il proprio " il mio progetto - copia "directory torna a" il mio progetto ". Quindi probabilmente esegui un altro commit abbastanza presto.

Git è una creazione geniale ma non puoi semplicemente "riprenderlo al volo": anche le persone che provano a spiegarlo troppo spesso presuppongono una conoscenza preliminare di altri VCS [Version Control Systems] e approfondiscono troppo profondo troppo presto e commettere altri crimini, come usare termini intercambiabili per "controllare" - in modi che a volte sembrano quasi calcolati per confondere un principiante.

Per risparmiarti molto stress devi praticamente leggere un libro su Git - mi raccomando "Version Control with Git" . E se puoi fidarti di me (o meglio delle mie cicatrici) quando dico "devo", ne consegue che potresti benissimo farloORA. Gran parte della complessità di Git deriva dalla ramificazione e quindi dal riemergere. Ma dalla tua domanda c'è nessuna ragione per cui le persone dovrebbero accecarti con la scienza .

Soprattutto se, ad esempio, questa è una situazione disperata e tu sei un principiante con Git!

PS: Un altro pensiero: è (ora) in realtà abbastanza semplice mantenere il repository Git ("repo") in una directory diversa da quella con i file di lavoro. Ciò significherebbe che non dovresti copiare l'intero repository Git usando la soluzione rapida e sporca di cui sopra. Guarda la risposta di Fryer usando --separate-git-dir here . Stai attento , però: se hai un repository "directory separata" che non copi e esegui un hard reset, tutte le versioni successive al commit di reset andranno perse per sempre, a meno che tu non abbia , come è assolutamente necessario, eseguire regolarmente il backup del repository, preferibilmente nel cloud (ad esempio Google Drive ), tra le altre posizioni.

13
mike rodent

Prova a resettare il commit desiderato -

git reset <COMMIT_ID>

(per controllare COMMIT_ID usa git log)

Ciò ripristinerà tutti i file modificati in stato non aggiunto.

Ora puoi checkout tutti i file non aggiunti di

git checkout .

Controlla git log per verificare le tue modifiche.

AGGIORNARE

Se hai solo uno commit nel tuo repository, prova

git update-ref -d HEAD

13
optimistanoop

Attenzione! Questo comando può causare la perdita della cronologia del commit, se l'utente inserisce erroneamente il commit errato. Hai sempre un backup extra del tuo git, dove altro, nel caso in cui tu faccia degli errori, allora sei un po 'più sicuro. :)

Ho avuto problemi simili e volevo tornare ai precedenti Commit. Nel mio caso non sono stato concepito per mantenere il commit più recente quindi ho usato Hard.

Ecco come l'ho fatto:

git reset --hard CommitId && git clean -f

Questo verrà ripristinato sul repository locale, qui dopo aver usato git Push -f aggiornerà il repository remoto.

git Push -f

Poiché i tuoi commit vengono spinti da remoto, devi rimuoverli. Lascia che il tuo ramo si sviluppi e viene spinto su Origin.

Devi prima rimuovere lo sviluppo da Origine:

git Push Origin :develop (note the colon)

Quindi devi sviluppare lo stato desiderato, lascia che l'hash del commit sia EFGHIJK:

git reset --hard EFGHIJK

Infine, Push si sviluppa nuovamente:

git Push Origin develop
11
George Ninan

Su GitKraken puoi fare questo:

  1. Fare clic con il tasto destro sul commit che si desidera ripristinare, scegliere: Ripristina questo commit/Difficile:

 enter image description here

  1. Fare nuovamente clic con il tasto destro sul commit, scegliere: Nome ramo corrente/Push:

 enter image description here

  1. Fai clic su Force Push:

 enter image description here

Obs. : È necessario fare attenzione perché tutte le cronologie di commit dopo il reset hardware sono perse e questa azione è irreversibile. Devi essere sicuro di cosa stai facendo.

10
Ângelo Polotto

Se vuoi correggere qualche errore nell'ultimo commit, una buona alternativa sarebbe usare git commit --amend command. Se l'ultimo commit non è indicato da alcun riferimento, questo farà il trucco, in quanto crea un commit con lo stesso genitore dell'ultimo commit. Se non c'è alcun riferimento all'ultima commit, verrà semplicemente scartato e questo commit sarà l'ultimo commit. Questo è un buon modo per correggere i commit senza ripristinare i commit. Tuttavia ha i suoi limiti.

10
Upul Doluweera

Per prima cosa prendi la stringa che identifica il commit in una certa data, facendo:

git rev-list -n 1 --before="2009-07-27 13:37" Origin/master

stampa l'identificatore di commit, prende la stringa (per esempio XXXX) e fa:

git checkout XXXX
9
Luca C.

Per il rollback (o per ripristinare):

  1. git revert --no-commit "commit-code-to-remove" HEAD (ad es. git revert --no-commit d57a39d HEAD)
  2. git commit
  3. git Push

Prova sopra due passi, e se trovi questo è ciò che vuoi, allora git Push.

Se trovi qualcosa di sbagliato, fai:

git revert --abort

9
Jagraj Singh

Può essere fatto molto più facilmente con SourceTree . Basta fare clic con il pulsante destro del mouse che stai cercando e selezionare "Acquista" dal menu.

 enter image description here

8
Marcin Szymczak

Ancora un'altra soluzione più semplice; devi cambiare ramo per farlo, ma in seguito puoi semplicemente eseguire:

git branch -f <<branchname>> 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
8
Aif

Non sono riuscito a ripristinare il mio manualmente per qualche motivo, quindi ecco come ho finito per farlo.

  1. Ho controllato il ramo che volevo avere, lo ho copiato.
  2. Controllato l'ultima filiale.
  3. Ho copiato il contenuto dal ramo che volevo alla directory del ramo più recente sovrascrivendo le modifiche e confermandolo.
7
Demodave
git reflog

Scegli il numero di HEAD (s) di git reflog, dove vuoi tornare e fare (per questo esempio scelgo il 12):

git reset [email protected]{12} --hard
7
Sérgio

Il modo meno complicato per ripristinare un ramo in un commit particolare in cui non è possibile modificare la cronologia che ho trovato è:

  1. verifica il commit o il ramo dal quale desideri tornare.
  2. Modifica .git/HEAD e cambia il riferimento al ramo su cui vuoi tornare.

Ad esempio:

echo 'ref: refs/heads/example' > .git/HEAD

Se poi fai lo stato git, dovresti vedere tutte le modifiche tra il ramo su cui ti trovi e quello che desideri ripristinare.

Se tutto sembra a posto, puoi impegnarti. Puoi anche usare git diff revert..esempio per assicurarti che sia lo stesso.

6
jgmjgm

Se si desidera annullare temporaneamente le modifiche perché

  • qualcuno ha commesso un codice che rompe la build o rompe la funzionalità su cui stai lavorando

Puoi cercare l'ultimo commit di lavoro usando git log ed eseguirlo

git rebase --onto <commitId>

Quando il ramo remoto sta funzionando di nuovo, puoi farlo

git pull --rebase

Questo metodo è migliore di git checkout per le modifiche temporanee, perché non sei in uno stato di distacco.

5
joseph

Ripristino di modifiche e commit di Staged

Il comando git reset ti consente di cambiare HEAD- l'ultimo commit che l'albero di lavoro punta al-del tuo repository. Modifica l'area di staging o l'area di staging e l'albero di lavoro. La capacità di Git di creare commit si comporta esattamente come vuoi, significa che a volte devi annullare le modifiche alle modifiche che hai organizzato con git add. Puoi farlo chiamando git reset HEAD <file to change>. Hai due opzioni per eliminare completamente le modifiche. git checkout HEAD <file(s) or path(s)> è un modo rapido per annullare le modifiche all'area di staging e alla struttura di lavoro. Fai attenzione con questo comando, tuttavia, perché rimuove tutte le modifiche al tuo albero di lavoro. Git non conosce tali cambiamenti poiché non sono mai stati commessi. Non è possibile ripristinare tali modifiche dopo aver eseguito questo comando. Un altro comando a tua disposizione è git reset --hard. È ugualmente distruttivo per il tuo albero di lavoro: qualsiasi modifica non vincolante o modifiche graduali vengono perse dopo l'esecuzione. Esecuzione di git reset -hard HEAD fa la stessa cosa di git checkout HEAD. semplicemente non richiede un file o un percorso per funzionare. È possibile utilizzare --soft con git reset. Reimposta il repository sul commit specificato e mette in scena tutte queste modifiche. Le modifiche che hai già messo in scena non sono influenzate, né i cambiamenti nel tuo albero di lavoro. Infine, puoi usare --mixed per resettare l'albero di lavoro senza mettere in scena alcuna modifica. Inoltre, non rilascia alcuna modifica che viene messa in scena.

Reverting Commits

A volte facciamo degli errori. Un commit che non doveva essere condiviso viene trasferito in un repository pubblico, un commit ha un bug che non può essere corretto e deve essere annullato, o forse non hai più bisogno di quel codice. Questi casi tutti chiama git revert. Il comando git revert fa esattamente quello che potresti aspettarti. Ripristina un singolo commit applicando un commit inverso alla cronologia. A volte è necessario annullare più commit per annullare completamente una modifica. Puoi usare -no-commit, oppure puoi utilizzare -n per dire a Git di eseguire il ripristino, ma basta interrompere il commit della modifica. Ciò ti consente di combinare tutti i revert commit in un commit, il che è utile se hai bisogno di ripristinare una feature che si estende su più commit. Assicurati di reimpostare i commit in ordine inverso: il nuovo commit prima. Altrimenti potresti confondere Git provando a ripristinare il codice che non esiste ancora.

2
SAIguru011