41 Domanda: Come faccio a ripristinare un repository Git su un commit precedente?

domanda creata a Mon, Jun 10, 2019 12:00 AM

Come faccio a passare dal mio stato attuale a uno snapshot fatto su un certo commit?

Se faccio git log, ottengo il seguente risultato:

 
$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <me@me.com>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <me@me.com>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <me@me.com>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <me@me.com>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

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

    
6891
  1. Related Come annullare l'ultimo commit Git? .
    2014-05-23 17: 57: 12Z
  2. Ecco un post molto chiaro e approfondito su come annullare le cose in git, direttamente da Github.
    2015-06-08 19: 41: 52Z
  3. Correlato: Rollback a un vecchio commit Git in un repository pubblico . Nota che quella domanda aggiunge un vincolo che il repository è pubblico.
    2015-10-19 09: 51: 42Z
  4. Adoro git, ma il fatto che ci siano 35 risposte a qualcosa che dovrebbe essere incredibilmente semplice espone un enorme problema con git. O sono i documenti?
    2018-01-03 22: 26: 59Z
  5. Potrebbero aggiungere una funzionalità di pulsante per quello come SVN nella cronologia
    2018-12-13 18: 29: 31Z
  6. 30 risposte                              30                         

    Dipende molto da cosa intendi per "ripristinare".

    Passa temporaneamente a un commit diverso

    Se vuoi tornare temporaneamente ad 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 a dove 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 definitivamente 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 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 gran parte di ciò nella sua descrizione. Un altro link utile è questa sezione git-scm.com che discute di git -revert.

    Se decidi di non voler tornare, dopotutto, 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)

        
    8799
    2018-04-04 17: 54: 07Z
    1. @ Commento di Rod su git revert HEAD~3 come il miglior wat da ripristinare indietro 3 commit è una convenzione importante.
      2012-08-22 15: 16: 45Z
    2. Potresti scrivere il numero intero? del tipo: git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
      2012-12-04 13: 58: 13Z
    3. @ MathiasMadsenStav Sì, puoi ovviamente specificare commit dall'intero SHA1. Ho usato gli hash abbreviati per rendere la risposta più leggibile e si tende a usarli anche se si sta digitando. Se stai copiando e incollando, usa assolutamente l'hash completo. Vedi Specifica delle revisioni in man git rev- parse per una descrizione completa di come puoi nominare commit.
      2012-12-04 16: 55: 52Z
    4. Per tornare al corrente il comando è 'git checkout master'
      2013-01-18 00: 33: 26Z
    5. Puoi usare git revert --no-commit hash1 hash2 ... e dopo questo commetti ogni singolo ripristino in un commit git commit -m "Message"
      2013-09-24 12: 12: 16Z

    Rogue Coder?

    Lavorare da solo e voglio solo che funzioni? Segui queste istruzioni di seguito, hanno funzionato in modo affidabile per me e molti altri per anni.

    Lavorare con gli altri? Git è complicato. Leggi i commenti sotto questa risposta prima di fare qualcosa di avventato.

    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 ramo corrente

    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 HEAD@{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 a un commit da un hash SHA in Git? .

        
    1465
    2019-06-13 02: 36: 39Z
    1. L'ho fatto, ma poi non sono stato in grado di eseguire il commit e il push nel repository remoto. Voglio un commit più vecchio specifico per diventare HEAD ...
      2012-09-24 18: 17: 28Z
    2. Significa che hai già inserito i commit che vuoi annullare. Può creare molti problemi per le persone che hanno controllato il codice e lavorato su di esso. Dal momento che non possono applicare il tuo impegno senza problemi sul loro. In tal caso, meglio fare un git revert. Se sei l'unico che usa il repo. Fai un git push -f (ma pensaci due volte prima di farlo)
      2012-12-05 04: 51: 51Z
    3. Avviso obbligatorio: non resettare a fondo se condividi il tuo ramo con altre persone che hanno copie dei vecchi commit, perché un hard reset come questo li costringerà a dover risincronizzare il loro lavoro con il ramo appena resettato. Il ripristino software è sicuro, tuttavia, nonché le ultime soluzioni in questa risposta .
      2014-06-28 20: 06: 00Z
    4. Voglio solo sottolineare che, in alternativa per la soluzione di reset software, invece di eseguire un reset misto prima e un hard reset per ultimo, puoi effettivamente fare il difficile ripristinare prima, come segue: git reset --hard 56e05fc; git reset --soft HEAD@{1}; git commit.
      2014-06-29 00: 20: 29Z
    5. @ nuton linus pauling stesso, il creatore di git, lo ha criticato per essere troppo complicato. Ha dichiarato che è stato "scioccato" e che è diventato così popolare data la sua complessità
      2015-05-18 23: 56: 00Z

    Qui ci sono un sacco di risposte complicate e pericolose, ma in realtà è facile:

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

    Questo ripristinerà tutto dall'HEAD all'hash di commit, il che significa che ricreerà lo stato di commit nell'albero di lavoro come se ogni commit da quando era tornato 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 sicuro e semplice per ripristinare uno stato precedente . Nessuna cronologia viene distrutta, quindi può essere utilizzata per i commit che sono già stati resi pubblici.

        
    1458
    2014-06-28 20: 12: 34Z
    1. Se vuoi davvero avere commit individuali (invece di ripristinare tutto con un grosso commit), puoi passare --no-edit invece di --no-commit, in modo da non devi modificare un messaggio di commit per ogni ritorno.
      2014-06-28 20: 11: 40Z
    2. Se uno dei commit tra 0766c053..HEAD è un'unione allora si verificherà un errore (da fare con no -m specificato). Questo può aiutare chi incontra questo: stackoverflow.com/questions/5970889/...
      2014-11-21 11: 55: 43Z
    3. Per vedere le differenze prima del commit usa git diff --cached.
      2015-11-06 18: 35: 20Z
    4. $ git revert --no-commit 53742ae..HEAD restituisce fatal: empty commit set passed
      2016-08-01 20: 30: 18Z
    5. @ AlexG perché è necessario inserire l'hash uno prima quello a cui si desidera tornare. Nel mio caso, gli hash erano come: 81bcc9e HEAD{0}; e475924 HEAD{1}, ... (da git reflog), e volevo annullare ciò che ho fatto in 81bcc9e, poi ho dovuto fare git revert e475924..HEAD
      2017-04-16 14: 22: 51Z

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

    git clean -i

        
    184
    2015-07-16 15: 31: 10Z
    1. Avviso obbligatorio: non farlo se condividi il tuo ramo con altre persone che hanno copie dei vecchi commit, perché usando un hard reset come questo li costringerà a dover risincronizzare il loro lavoro con il ramo appena resettato. Per una soluzione che spiega in dettaglio come ripristinare i commit in modo sicuro senza perdere il lavoro con un hard reset, vedi questa risposta .
      2014-06-28 20: 03: 54Z
    2. I second @ l'avvertimento di Cupcake ... sii molto consapevole delle conseguenze. Nota, comunque, che se il tuo bisogno è davvero quello di far scomparire per sempre quei commit dalla storia, questo metodo + reset clean lo farà, e avrai bisogno che force spinga i tuoi rami modificati a qualsiasi e tutti i telecomandi.
      2014-10-29 14: 46: 25Z
    3. git clean -f PERICOLO PERICOLO
      2015-07-16 14: 59: 20Z
    4. Imposta la testa della mia copia locale sul commit desiderato. Ma poi non posso spingere alcun cambiamento perché è dietro il telecomando. E se tiro dal telecomando, finisce dove era l'ultimo commit sul ramo remoto. Come posso cancellare completamente (da ovunque) diversi commit sia sulla mia copia locale che sono stati inseriti?
      2017-10-22 11: 47: 32Z
    5. @ Ade .. Puoi usare la flag git push -f .. Ma fai attenzione, sostituirà il telecomando .. Assicurati di sapere cosa vuoi fare ...
      2017-10-23 09: 02: 57Z

    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ò esserci 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 - il che significa che HEAD punta a un commit precedente nella cronologia è chiamato detached HEAD .

     Inserisci la descrizione dell'immagine qui

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

     Inserisci la descrizione dell'immagine qui


    Alcune opzioni su come eseguire il ripristino 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
    

    Verificherà 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 il reflog. git reflog visualizzerà tutte le modifiche che hanno aggiornato il HEAD e verificando la voce di riferimento desiderata reimposterà il HEAD a questo commit.

    Ogni volta che l'HEAD viene modificato ci sarà una nuova voce nel reflog

     
    git reflog
    git checkout HEAD@{...}
    

    Questo ti riporterà al commit desiderato

     Inserisci la descrizione dell'immagine qui


    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.
    
    • Nota: ( Dal Git 2.7 ) puoi anche usare il git rebase --no-autostash.

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

     Inserisci la descrizione dell'immagine qui

        
    143
    2018-07-04 19: 25: 17Z
    1. Suggerimento eccellente su git reflog, è esattamente ciò di cui avevo bisogno
      2016-03-13 21: 25: 01Z
    2. Ahi! Tutto ciò sembra terribilmente complicato ... non c'è un semplice comando che ti fa solo fare un passo indietro nel processo? Come passare dalla versione 1.1 del tuo progetto alla versione 1.0? Mi aspetterei qualcosa di simile: git stepback_one_commit o qualcosa del genere ....
      2016-03-20 14: 35: 15Z
    3. c'è: git reset HEAD^ --hard`
      2016-03-20 14: 38: 43Z
    4. @ Kokodoko Sì, è orribilmente complicato ... e unesempio perfetto di quanto poca considerazione gli esperti hanno per le persone che stanno appena iniziando. Si prega di fare riferimento alla mia risposta qui, e anche al libro che raccomando in esso. Git NON è qualcosa che puoi semplicemente prendere in modo intuitivo. E posso essere assolutamente certo che CodeWizard non lo ha fatto.
      2016-08-29 17: 17: 51Z

    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 desideri eseguire il rollback a un numero di revisione specifico, puoi farlo utilizzando il suo hash SHA.

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

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

        
    125
    2014-03-04 17: 25: 52Z
    1. Questo è morbido e delicato: privo di rischi se non hai spinto il tuo lavoro
      2017-01-18 10: 04: 18Z

    Ho provato un sacco di modi per annullare le modifiche locali in Git, e sembra che funzioni al 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ù comodo 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 del git reset --hard HEAD per cancellare tutti i nuovi file creati dall'ultimo commit poiché questo è ciò che la maggior parte della gente si aspetta che io creda quando si ripristina l'ultimo commit.

        
    105
    2014-06-24 20: 08: 20Z

    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 utilizzare:

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

    Quindi salverà le tue modifiche.

        
    99
    2016-07-03 06: 30: 27Z
    1. Ho provato 1/2 una dozzina di risposte in questo post fino a quando non sono arrivato a questo .. tutti gli altri, la mia git config continuava a darmi un errore quando cercavo di Spingere. Questa risposta ha funzionato. Grazie!
      2016-09-16 19: 47: 15Z
    2. Un dettaglio per me è che ho perso i diff ... che volevo vedere per vedere cosa avevo fatto nel commit che non funzionava. Quindi la prossima volta salverei i dati prima di emettere questo comando di reset
      2016-09-16 19: 49: 36Z
    3. Questo è stato l'unico modo per annullare una brutta unione, il ripristino non ha funzionato in quel caso. Grazie!
      2017-01-19 20: 07: 19Z

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

    Ripristina senza conservare le modifiche:

     
    git reset --hard <commit>
    

    Ripristina mantenendo le modifiche:

     
    git reset --soft <commit>
    

    Spiega: utilizzando git reset, puoi ripristinare uno stato specifico, è normale utilizzarlo con un hash di commit come puoi vedere sopra.

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


    - morbido

    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 passa ai file.


    - difficile

    Stai attento con questo flag, resetta l'albero di lavoro e tutte le modifiche ai file tracciati e tutto sarà cancellato!


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

     git resettato su un commit

        
    65
    2019-02-05 13: 24: 37Z

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

     
    git reset --hard <commit_hash>
    git push origin <branch_name> --force
    

    Il tasto qui sta forzando il push, nessun commit extra /messaggio di commit ecc.

        
    59
    2018-04-23 01: 47: 59Z
    1. Questo ha funzionato per me, ma è necessario fare attenzione perché tutta la cronologia dei commit dopo il ripristino completo viene persa e questa azione è irreversibile. Devi essere sicuro di cosa stai facendo.
      2018-04-19 19: 34: 15Z

    Supponiamo di avere i seguenti commit in un file di testo denominato ~/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 Bash script di 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
    

    Questo riporta tutto allo stato precedente, incluse le creazioni di file e directory, e le eliminazioni, le trasferiscono nel 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
    2014-06-29 00: 13: 03Z
    1. Puoi fare un git revert HEAD~3 per rimuovere gli ultimi 3 commit
      2012-02-19 18: 59: 22Z
    2. @ Rod - No, non è giusto. Questo comando ripristinerà il commit che è il terzo nonno di HEAD (non gli ultimi tre commit).
      2012-09-11 22: 13: 05Z
    3. @ kflorence Ok grazie per le informazioni. git revert -n master~3..master~1 funzionerebbe? (Come visto da kernel.org/pub/software/scm /git /docs /git-revert.html )
      2012-09-12 01: 59: 58Z
    4. @ Rod - Suona bene, sicuramente è una sintassi brutta, non è vero? Ho sempre trovato il commit sul commit che voglio "ripristinare" e poi commettere quello più intuitivo.
      2012-10-01 01: 12: 03Z
    5. C'è un molto più facile modo per farlo ora che con uno script come questo, usa git revert --no-commit <start>..<end>, perché git revert accetta un intervallo di commit in new (o tutto?) versioni di Git. Si noti che l'inizio dell'intervallo non è incluso nel ripristino.
      2014-06-28 20: 02: 39Z

    Al. extraternative alle soluzioni di Jefromi

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

    Per essere chiari, queste alternative non sono il modo migliore per ripristinare i commit , Le soluzioni di Jefromi sono , ma voglio solo far notare che puoi anche usare questi altri metodi per ottenere lo stesso risultato di git revert.

    Alternativa 1: Reimpostazioni rigide e morbide

    Questa è una versione leggermente modificata della soluzione di Charles Bailey per Ripristina un commit da un hash SHA 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 HEAD@{1}
    
    # Commit the changes
    git commit -m "Revert to <commit>"
    

    Questo funziona fondamentalmente usando il fatto che le reimpostazioni software lasceranno lo stato del precedente commit messo in scena nell'indice /area di staging, che puoi quindi commettere.

    Alternativa 2: Elimina la struttura attuale e Sostituisci con quella nuova

    Questa soluzione proviene dalla soluzione di svick per Effettua il checkout del 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 dal <commit>.

        
    56
    2017-05-23 11: 47: 32Z
    1. Informazioni sull'alternativa 1, una domanda veloce: facendo così non perdiamo tra il commit giusto?
      2014-12-02 10: 14: 33Z
    2. in Alternativa 2, i punti rappresentano ciò che in quei comandi?
      2014-12-02 10: 21: 40Z
    3. @ Bogac - i punti indicano un percorso di file, in questo caso la directory corrente, quindi si presume che tu stia eseguendo dalla radice della tua copia di lavoro.
      2014-12-02 19: 06: 38Z
    4. L'avviso viene ripetuto più volte nella risposta, ma qualcuno potrebbe aggiungere perché questi sono non il modo migliore - confrontato, per qualcosa come git revert HEAD~2..HEAD dalla soluzione collegata di @ Cascabel (@ Jefromi). Non vedo il problema.
      2018-12-28 02: 16: 08Z

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

     
    # 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 di un blog (ora non esiste più)

    Nota che questo è il ripristino e forzatura della modifica al telecomando, in modo che se altri membri del tuo team hanno già tirato git, causeranno problemi per loro. Stai distruggendo la cronologia delle modifiche, che è un motivo importante per cui le persone usano git in primo luogo.

    Meglio usare il ripristino (vedi altre risposte) piuttosto che ripristinare. Se sei un team one man, allora probabilmente non ha importanza.

        
    56
    2019-04-28 19: 59: 43Z
    1. In che modo questa risposta è diversa dalla miriade di altri?
      2016-05-10 17: 46: 51Z
    2. Il link è rotto.
      2016-07-03 10: 59: 27Z
    3. Questo è sfortunato. Ho mandato un'email al blogger - si spera che ce l'abbia ancora!
      2016-07-04 19: 29: 37Z
    4. 2016-09-01 17: 51: 49Z
    5. La maggior parte degli altri suggerimenti su come risolvere questo problema manca nella sintassi push. Ha funzionato alla grande.
      2017-03-24 16: 20: 56Z

    Ecco un modo molto più semplice per tornare a un commit precedente (e averlo in uno stato non limitato, per utilizzarlo come preferisci):

     
    git reset HEAD~1
    

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

        
    51
    2016-07-03 10: 56: 38Z
    1. non ha funzionato, un git pull dopo questo risultato: errore: le tue modifiche locali ai seguenti file verrebbero sovrascritte dall'unione:
      2016-11-05 00: 21: 33Z
    2. @ malhal Questo perché hai avuto modifiche non modificate. Stash /ripristinali e funzionerà senza quell'errore.
      2017-01-22 13: 37: 38Z

    Dopo tutte le modifiche, quando premi tutti questi comandi, potresti dover usare:

     
    git push -f ...
    

    E non solo git push.

        
    34
    2013-09-28 19: 07: 07Z
    1. Avviso obbligatorio: non farlo se condividi il tuo ramo con altre persone che hanno copie dei vecchi commit, perché usando una spinta di forza come questa li costringerà a dover risincronizzare il loro lavoro. Per una soluzione che spiega in dettaglio come ripristinare i commit in modo sicuro senza perdere il lavoro con un push forzato, vedi questa risposta .
      2014-06-28 20: 00: 19Z
    2. A volte questo è ciò che vuoi. Esempio: commit e spinto diversi commit al ramo sbagliato (ramo A). Dopo il cherry-picking al ramo B, voglio che questi commit vengano rimossi dal ramo A. Non vorrei tornare, poiché il ripristino verrebbe più tardi applicato quando i rami A e B vengono uniti insieme. Esegui un reset --hard < commitId > nel ramo A seguito da una spinta forzata rimuove questi commit dal ramo preservandoli nel ramo B. Posso farcela con questo perché so che nessun altro si sta sviluppando sul ramo A.
      2014-10-22 20: 44: 19Z
    3. Grazie! Non riuscivo a capire come ottenere il ramo remoto per abbinare il mio ramo locale, solo bisogno di fare una spinta forzata.
      2017-02-06 12: 49: 58Z

    Esiste un comando (non una parte del core Git, ma è nel pacchetto git-extras ) in particolare per ripristinare e mettere in scena i vecchi commit:

     
    git back
    

    Per la pagina man , può anche essere usato come tale:

     
    # Remove the latest three commits
    git back 3
    
        
    34
    2014-06-28 20: 19: 45Z

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

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

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

      $ git log -n 4

    3. Ripristina la cronologia della cronologia del tuo repository usando il git reset --hard HEAD~N dove N è il numero di commit che vuoi recuperare. Nell'esempio seguente la testa dovrebbe essere indietro di uno commit, fino all'ultimo commit nella cronologia del repository:

    4. Spingi la modifica su git repo usando git push --force per forzare il push la modifica.

    Se vuoi git repository ad un commit precedente

     
    git pull --all
    git reset --hard HEAD~1
    git push --force
    
        
    29
    2018-07-05 20: 56: 59Z

    Ripristina il commit più recente e ignora tutte le modifiche locali:

     
    git reset --hard HEAD
    
        
    27
    2018-07-04 19: 28: 44Z

    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 l'HEAD punti, fai

     
    git reset --hard HEAD~1
    

    o git reset --hard HEAD~2 o qualsiasi altra cosa.

        
    26
    2014-06-28 19: 51: 32Z
    1. Avviso obbligatorio: non farlo se condividi il tuo ramo con altre persone che hanno copie dei vecchi commit, perché usando un hard reset come questo li costringerà a dover risincronizzare il loro lavoro con il ramo appena resettato. Per una soluzione che spiega in dettaglio come ripristinare i commit in modo sicuro senza perdere il lavoro con un hard reset, vedi questa risposta .
      2014-06-28 19: 57: 00Z
    2. Inoltre, per essere chiari, git show HEAD equivale semplicemente a usare git log HEAD -1.
      2014-06-28 19: 58: 54Z

    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, fai:

     
    git reset --hard <SHA>
    
        
    20
    2016-07-03 10: 21: 53Z

    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 aggiustò. Eseguendo in precedenza il git add -A ., ha tracciato esplicitamente tutti loro con git, per essere cancellati dal reset.

        
    20
    2016-07-03 10: 55: 25Z

    Questo è un altro modo per reimpostare direttamente un commit recente

     
    git stash
    git stash clear
    

    Cancella direttamente tutte le modifiche che hai apportato 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
    2016-07-03 10: 57: 18Z
    1. NOTA: i nuovi file non aggiunti all'indice non sono nascosti. Devi aggiungerli o eliminarli manualmente.
      2016-12-08 14: 08: 46Z
    2. Perché oh perché cancellare lo stash? Oltre ad essere una non-soluzione, til suo è in realtà dannoso. La lettura della primissima frase della domanda invalida immediatamente la soluzione di stash (che potrebbe essere utile SOLO per ripristinare il commit LAST).
      2019-03-07 07: 35: 51Z

    Credo che alcune persone possano venire a questa domanda volendo sapere come eseguire il rollback delle modifiche apportate nel proprio master, ad esempio buttare via tutto e tornare all'origine /master, nel qual caso, eseguire questa operazione:

     
    git reset --hard origin/master
    

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

        
    19
    2017-03-20 10: 18: 20Z

    Revert è il comando per il rollback dei commit.

     
    git revert <commit1> <commit2> 
    

    Esempio:

    git revert 2h3h23233

    È in grado di prendere distanza dal HEAD come di seguito. Qui 1 dice "revert last commit."

    git revert HEAD~1..HEAD

    e quindi fare git push

        
    16
    2016-05-27 06: 05: 57Z

    Ripristina commit più recente:

     
    git reset --hard HEAD
    

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

    Ripristina un vecchio commit: Il modo più rapido per ripristinare una versione precedente è utilizzare il comando reset:

     
    # Resets index to former commit
    git reset 56e05fced 
    
    # Moves pointer back to previous HEAD
    git reset --soft HEAD@{1}
    
    # Updates working copy to reflect the new commit
    git reset --hard
    

    Questo riavvolgerà il 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 viene fornito con un paio di opzioni, una delle più interessanti è la flag --soft. Se lo usi al posto di --hard, Git manterrà tutte le modifiche in quei commit "annullati" come modifiche locali.

    Ripristino di una revisione in un nuovo ramo locale

    Come detto, l'utilizzo del comando di 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 modo più sicuro nel caso in cui preferisci che il tuo attuale ramo HEAD resti intatto. 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, puoi anche lasciarlo creare un nuovo ramo (chiamato 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
    2018-08-31 11: 08: 13Z

    Se la situazione è urgente , e vuoi solo fare ciò che l'interrogante ha chiesto in modo rapido e sporco , supponendo che il tuo progetto sia nella directory "my progetto ":

    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 che contiene il commit recuperato (o dargli un nome temporaneo) e rinominare la propria directory "my project - copy" in "my project". Quindi probabilmente esegui un altro commit abbastanza presto.

    Git è un bcreazione rilliant ma non puoi semplicemente "riprenderlo al volo": anche le persone che cercano di spiegarlo troppo spesso presuppongono una conoscenza preliminare di altri VCS [Version Control Systems] e approfondiscono troppo in profondità 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 assolutamente leggere un libro su Git - ti consiglio " Controllo versione con Git ". E se puoi fidarti di me (o meglio delle mie cicatrici) quando dico "devo", ne consegue che potresti anche farlo ORA . Gran parte della complessità di Git deriva dalla ramificazione e quindi dal riemergere. Ma dalla tua domanda non c'è nessuna ragione per cui le persone dovrebbero accecarti con la scienza .

    Specialmente 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 il quick & soluzione sporca. Vedi la risposta di Fryer usando --separate-git-dir qui . Sii avvisato , tuttavia: se disponi di 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 avere, come è assolutamente necessario, eseguire regolarmente il backup del repository, preferibilmente nel cloud (ad es. Google Drive ) tra gli altri luoghi.

        
    13
    2017-05-23 11: 55: 13Z

    Prova a ripristinare il commit desiderato -

    git reset <COMMIT_ID>

    (per controllare COMMIT_ID usa git log)

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

    Aggiorna

    Se hai un solo impegno nel repository, prova

    git update-ref -d HEAD

        
    13
    2018-04-17 10: 02: 40Z

    Poiché i tuoi commit vengono inviati in remoto, devi rimuoverli. Consentitemi di pensare che il vostro ramo si sviluppi e venga spinto sull'origine.

    Devi prima rimuovere lo sviluppo dall'origine:

     
    git push origin :develop (note the colon)
    

    Quindi devi sviluppare lo stato che desideri, supponiamo che l'hash del commit sia EFGHIJK:

     
    git reset --hard EFGHIJK
    

    Infine, continua a sviluppare nuovamente:

     
    git push origin develop
    
        
    11
    2017-04-19 07: 18: 34Z
      

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

    Ho avuto un problema simile e volevo tornare a Commit precedente. 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 si aggiornerà il repository remoto.

     
    git push -f
    
        
    11
    2018-02-02 13: 51: 57Z

    Se vuoi correggere qualche errore nell'ultimo commit, una buona alternativa sarebbe usare il comando git commit --amend . 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 good modo di correggere i commit senza ripristinare i commit. Tuttavia ha i suoi limiti.

        
    10
    2015-07-01 11: 35: 54Z
fonte posta Qui