come ripristinare un repository Git ad una commit precedente

come faccio a tornare dal mio stato attuale ad un'istantanea fatta su una certa commit?

se faccio git log, allora ottengo il seguente output:

$ 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 la commit dal 3 novembre, cioè commit 0d1d7fc?


En title : How to revert a Git repository to a previous commit

184 Comments:

  1. questo dipende molto da quello che intendi con "revert".

    passare temporaneamente ad una commit diversa

    se vuoi tornare temporaneamente ad esso, ingannare, poi tornare a dove sei, tutto quello che dovete fare è controllare la commit desiderata:

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

    o se vuoi fare commit mentre sei lì, vai avanti e crea un nuovo branch mentre sei lì:

    git checkout -b old-state 0d1d7fc32
    

    per tornare a dove eri, controlla il ramo su cui eri di nuovo. (se hai fatto delle modifiche, come sempre quando cambi rami, dovrai affrontarle nel modo più appropriato. si potrebbe reimpostare per buttarli via; si potrebbe stash, checkout, stash pop per portarli con te; si potrebbe metterli a un ramo lì se si desidera un ramo lì.)

    hard delete commit inediti

    se, d'altra parte, si vuole veramente sbarazzarsi di tutto quello che hai fatto da allora, ci sono due possibilità. uno, se non hai pubblicato nessuno di questi commit, resettare:

    # 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 si rovinare, hai già buttato via le modifiche locali, ma si può almeno tornare a dove eri prima di reimpostare di nuovo.

    Annulla commit pubblicati con nuovi commit

    d'altra parte, se hai pubblicato il lavoro, probabilmente non si desidera ripristinare il ramo, dal momento che questo è effettivamente riscrivere la storia. in questo caso, si potrebbe effettivamente ripristinare le commit. con Git revert ha un significato molto specifico: crea un commit con la patch inversa per cancellarlo. in questo modo non riscrivere alcuna storia.

    # 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
    

    il manuale git-revert in realtà copre un sacco di questo nella sua descrizione. un altro link utile è questa sezione git-scm.com che parla di git-revert.

    se si decide che non si desidera ripristinare dopo tutto, è possibile ripristinare il revert (come descritto qui) o ripristinare prima del revert (vedere la sezione precedente).


    questa risposta potrebbe essere utile anche in questo caso: come spostare HEAD indietro in una posizione precedente? (testa staccata)

    1. ho provato il tuo primo metodo, ma poi quando sono tornato a padroneggiare e ho provato a fondere il nuovo ramo che diceva Already up-to-date.. ho risolto il mio problema copiando i file dal nuovo ramo verso e cartella esterna, controllando master indietro, poi copiare i file indietro in sovrascrittura manuale tutto poi git add ing e git commit ing tutto per padroneggiare. dopo di che ho cancellato il nuovo (ma temporaneo) ramo.
    1. solo una cosa... come posso tornare alla testa? dopo aver fatto git checkout 0d1d7fc32??
    1. @jaime Per "testa" presumo che intendi "il ramo che avevo precedentemente controllato? git checkout - controlla il pensiero precedente aveva controllato; git checkout <branch> sarebbe il modo esplicito. (come per qualsiasi cosa su Git, fai attenzione a eseguire comandi se non capisci cosa fanno.)
    1. probabilmente hai fatto controllare un branch, non solo un commit - e probabilmente dovresti capire la differenza prima di staccare deliberatamente HEAD di nuovo.
    1. potresti scrivere l'intero numero? come: git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
    1. @MathiasMadsenStav Sì, ovviamente puoi specificare le commit con l'intero SHA1. ho usato hash abbreviati per rendere la risposta più leggibile, e si tende anche ad usarli se si sta digitando fuori. se si sta copiando e incollando, con tutti i mezzi utilizzare l'hash completo. vedere Specificare le revisioni in man git rev-parse per una descrizione completa di come si possono nominare le commit.
    1. ho eseguito 'git checkout 0d1d7fc32' per tornare temporaneamente. ora come faccio a tornare al più tardi? il mio ultimo non appare più in 'git log'
    1. Git community book link è morto. è questa una buona sostituzione? http://git-scm.com/book/en/Git-Basics-Undoing-Things
    1. non perdetevi la RANGE (da.. a) come in git revert HEAD~2..HEAD. succede.........
    1. perché usare git stash && git reset --hard && git stash pop? non sarebbe git reset 0d1d7fc32 raggiungere lo stesso? --mixed è di default per reset, che lascia l'albero di lavoro fuori scena come prima del reset.
    1. @gregers Non se alcune delle modifiche sono in file che dovranno essere reimpostati (sono state modificate nelle commit da perdere nel reset).
    1. non dovrebbe essere git checkout -b old-state 0d1d7fc32 git checkout 0d1d7fc32 -b old-state invece?
    1. @Yarin No. dalle dichiarazioni di utilizzo in cima alla pagina man, parafrasato: git checkout [-b <new_branch>] [<start_point>]. quello che hai scritto potrebbe funzionare anche, ma non è l'ordine normale di opzioni e argomenti, e non è documentato come funziona.
    1. btw, se hai creato alcuni file e poi reimpostare, assicurarsi di eseguire git clean -f -d -n per vedere quali file non sono tracciati, e git clean -f -d per eliminarli.
    1. @Yarin's risposta è più sicuro. si prega di dare un'occhiata prima di decidere cosa fare.
    1. @DrBeco Non è così semplice come sicuro o meno; le risposte non fanno tutte la stessa cosa. la risposta di Yarin è un caso particolare dell'ultima delle opzioni in questa risposta.
    1. dal momento che OP non ha specificato se s / he vuole un revert temporaneo / unificato / pubblicato, la tua risposta è sicuramente completa e l'ho upvotato. ma il modo semplice Yarin approccio terza opzione è IMHO molto meglio da usare, ricordare, ed evitare errori. semplice è buono.
    1. esempio Ho fatto 3 commit, c1 C2 C3 in ordine, ora mi rendo conto dopo C1 tutto quello che ho fatto era spazzatura, quindi voglio tornare a quello stato e remoto le commit verso l'alto di C1 completamente vale a dire. stato del file dovrebbe essere. ripristinato in C1 e git log dovrebbe mostrare solo le commit C1 e precedenti, usando git reset --hard C1ID sarà perfetto? .. grazie sono un principiante di git
    1. si noti inoltre che se ci sono dei tag sulle commit che stai cercando di eliminare si vorrà eliminarli con git tag -d some-tag-name
    1. non capisco la tua spiegazione a @gregers. Anche se alcuni file sono modificati nelle commit da perdere, le loro copie sono ancora nell'albero di lavoro. non vedo quando stashing può essere utile nello scenario di "Hard delete commit inediti" invece di un semplice git reset --mixed.
    1. @DonHatch Forse è perché non era la domanda, e pienamente rispondendo che aggiunge in molto più complessità, mentre le risposte semplici sono fondamentalmente "fare questo di nuovo". per esempio, se usi git revert, allora decidi di non volere, tornare al punto in cui eri prima equivale a fare di nuovo una delle cose in questa risposta - ripristinare il revert, resettare prima del revert, o fare il checkout prima del revert. posso modificare un po ', ma se avete una domanda diversa, fare una nuova domanda.
    1. vedo migliorato la risposta per renderla più vicina a come pubblicizzato, grazie: -) Questo rende la risposta più utile, a me e, sembra, a molti altri che hanno commentato in questo thread. penso che potrebbe essere migliorato ancora di più se questa parte della ricetta potrebbe essere resa un po 'più esplicita, soprattutto per un nuovo utente / casual per il quale non è necessariamente ovvio che attualmente hanno un ramo chiamato "master" controllato. suggerimento: "per tornare al punto in cui eri, basta controllare il ramo in cui eri di nuovo, usando git checkout - o il nome del ramo esplicito come 'master'"
    1. nota Non dimenticare di "deproteggere" il tuo ramo in questione quando usi resetti duri su gitlab o github.
    1. @Jefromi, dopo "git checkout 0d1d7fc32. ", l'HEAD è già staccato? quindi "git commit" non può fare nulla con l'HEAD in pericolo.
    1. @user1914692 No, che non stacca HEAD. il . è importante - dirige git per controllare lo stato da 0d1d7fc32 nella directory corrente, ma lascia HEAD dove si trovava. e 'lo stesso che usare qualcosa come git checkout other-branch path/to/file - che ti lascerà sul ramo corrente, e basta controllare il file dato. in questo caso stiamo controllando l'intera directory corrente invece di un solo file, ma ancora non cambiando HEAD.
    1. @Jefromi Grazie. questa è un'opzione molto utile. sembra che quando il manuale di Git parla di "git checkout commit", non dica che c'è un'altra opzione da aggiungere "." per evitare il distacco della TESTA. le tue informazioni da questa parte sono: "Git checkout [-p | --patch] [--]..."?
    1. @user1914692 Sì, . è un percorso. qualsiasi cosa nella pagina man di git checkout riguardante il controllo di percorsi specifici si applica qui, inclusa la prima frase di quello che hai citato: "quando o --patch sono dati, git checkout non cambia branch."
    1. @Jefromi Il manuale dice ".. non cambia rami". ma non dice che non staccare HEAD. vedi la mia domanda nel link http://stackoverflow.com/questions/33656072/git-can-i-check-out-a-commit-without-head-detached, qualcuno dice: "se vuoi controllare una commit che non è l'ultima commit di un branch, è fondamentalmente impossibile verificarla mentre allo stesso tempo HEAD fa riferimento a un branch"
    1. @user1914692 Rilevamento HEAD è una sottocategoria di rami di commutazione. quando si stacca HEAD, si passa ad essere su un ramo per essere su nessun ramo. la differenza tra il passaggio a un ramo e la testa di distacco è una differenza nella destinazione, ma hai ancora lasciato il ramo corrente. quindi, quando questo paragrafo dice che non cambia ramo, significa che HEAD rimane lo stesso - se si fa git checkout <branch> <path>, non passa a quel ramo, e se si fa git checkout <commit> <path> non staccare HEAD passando a quella commit.
    1. @user1914692 Questo è tutto totalmente coerente con l'altra domanda si punta a, naturalmente. non c'è ancora modo di controllare una commit non-branch senza staccare HEAD. è possibile controllare tutti i contenuti di tale commit come questo, ma HEAD è ancora dove era. se commetti di nuovo commetti su dove eri prima, non su quell'altro commit. non hai effettivamente verificato un altro commit.
    1. @Jefromi Ora sono confuso. hai detto "git checkout non stacca HEAD passando a quella commit". poi hai detto "Non c'è ancora modo di controllare effettivamente una commit non-branch senza staccare HEAD."
    1. come descritto nella risposta, sono tornato ad una commit precedente: git checkout 0d1d7fc32, poi ho ingannato in giro, e ora git non mi farà tornare indietro: le tue modifiche locali ai seguenti file saranno sovrascritte da checkout: Quiz2 / ViewControler.swift Per favore, commetti le tue modifiche o le accantoni prima di poter cambiare branch. abortire --come faccio a tornare?
    1. @7stud La risposta è esattamente la stessa come se si ha quel messaggio quando si passa rami in qualsiasi altro caso, ma sono andato avanti e modificato in un po 'per affrontarlo. si potrebbe voler fare una nuova domanda se siete confusi su come passare rami.
    1. @Jefromi, Se creo un ramo per ingannare, quando sono finito commetto, poi torna a master, poi elimina il ramo: git branch -D fool_around Come funziona quando torno a un commit precedente e giro in giro?
    1. perché commetti se cancelli il ramo? basta azzerare. ma se preferisci fare commit e poi perdere traccia della commit cancellando il branch, va bene. puoi farlo senza che ci sia anche un ramo; perderai la traccia della commit quando ti allontanerai. (questo è il motivo per cui ci sono tutti i tipi di avvertimenti e messaggi su HEAD staccato - si sta impegnando da qualche parte senza un ramo per tenere traccia di esso.)
    1. @Jefromi, Perché commetti se cancelli il ramo? -- Questo è l'unico modo che so come farlo. : (in ogni caso, ho ancora bisogno di sapere come tornare dopo aver controllato una commit precedente. se hai fatto delle modifiche, come sempre quando cambi rami, dovrai affrontarle nel modo più appropriato. potresti reimpostare per buttarli via --come faccio?
    1. @7stud https://git-scm.com/docs/git-reset o http://stackoverflow.com/questions/2530060/can-you-explain-what-git-reset-does-in-plain-english
    1. @tyegah123 git checkout master ha ragione se sei su master. generalmente, puoi fare git checkout per tornare alla commit più recente. e se fai delle modifiche in una commit precedente allora cerca di tornare a master, ti dirà i comandi per salvare queste modifiche in un nuovo branch o scaricarle e tornare al codice più recente.
    1. solo per notare, se hai pasticciato le cose facendo una fusione o solo cambiamenti generali, si noterà che non si può fare solo quanto sopra. in primo luogo dovete commettere i vostri file di problema. semplicemente non spingere.
    1. @Jefromi Che cosa se voglio riscrivere la storia perché non ho mai bisogno di questi cambiamenti più. ho bisogno di tornare indietro di tre commit e non voglio avere nulla di fronte a quella commit desiderata? sono l'unico nel repo in modo da non interessare a chiunque altro. quale comando devo usare per eliminare tutti i cambiamenti prima della commit che voglio essere?
    1. @Jefromi No, ma sono già pubblicati. voglio dire che sono nel remoto. perché ho eseguito git push origin master ma ora voglio cancellare de las tre commit sul mio locale e poi spingere le modifiche per il remoto anche COMPLETAMENTE DELETE qualsiasi commit di fronte a quello desiderato.
    1. @AlexVentura Suoni come già sapete è necessario fare solo questo, e spingere. se hai provato, si dovrebbe aver ottenuto un errore su un non-fast-forward push, che è possibile sovrascrivere con git push --force. ci sono un sacco di domande esistenti su questo, ad esempio http://stackoverflow.com/q/10510462/119963http://stackoverflow.com/q/6310208/119963http://stackoverflow.com/q/10298291/119963
    1. @Jefromi Sì, ho fatto quello che hai detto e ho ottenuto questo errore e poi ho usato force. ma siccome non ho molta esperienza con Git non sono pienamente convinto, quindi mi piacerebbe sapere se questo è il modo giusto o se c'è un modo per confermare ed essere sicuri che non c'è nulla davanti al mio commit reale e semplicemente sovrascrivere la storia in locale e remoto?
    1. @AlexVentura Penso che sei al punto in cui si dovrebbe davvero fare una nuova domanda. commenti qui sono per chiarire la risposta esistente. se hai bisogno di aiuto per esaminare il contenuto dei repository, o quali commit sono su quali branch, questo è un altro argomento.
    1. git checkout -b old-state 0d1d7fc32 mi dà un errore fatal: Cannot update paths and switch to branch 'oldApi' at the same time. Ho dovuto farlo separatamente prima chiamando git checkout 0d1d7fc32 e poi git checkout -b old-state.
    1. sono abbastanza sicuro che la domanda sta chiedendo come spostare il repository indietro su come era quando commit è stato spinto. così GIT Domande in particolare bisogno di applicare la moderazione nella lotta alla tentazione di sovra-informare in mostra di conoscenza e complessità. la domanda è chiara per tornare indietro: non tornare indietro con x, y, z finché p, q, r, s se si desidera passare tra i rami a, b, c. 1 ramo, 1 domanda, 1 punto nel tempo per tornare a.
    1. @JordanStefanelli Onestamente, anche dal tuo commento, in realtà non capisco quale di queste opzioni si pensa che il OP vorrebbe. e certamente non credo che fosse chiaro quale di questi voleva il OP - "revert" può avere un sacco di significati diversi, e sembrava che la conoscenza di alcune opzioni, ognuna delle quali può essere la scelta giusta in diverse situazioni, sarebbe utile per gli OP e per i lettori futuri. oserei dire che l'accettazione e le votazioni hanno dimostrato questo.
    1. quindi cosa succede se voglio solo ripristinare l'ultima commit pubblicata - posso farlo da git revert HEAD?
  2. dire di avere le seguenti commit in un file di testo chiamato ~/commits-to-revert.txt (ho usato git log --pretty=oneline per ottenerle)

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

    creare uno script di shell Bash per ripristinare 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 restituisce tutto allo stato precedente, incluse le creazioni di file e directory, e le eliminazioni, lo commetti nel tuo ramo e conserverai la cronologia, ma lo hai ritornato alla stessa struttura di file. perché Git non ha un git revert --to <hash> è oltre di me.

    1. @Rod - No, non è giusto. questo comando ripristina la commit che è la terza nipote di HEAD (non le ultime tre commit).
    1. @kflorence Ok grazie per le informazioni. sarebbe git revert -n master~3..master~1 lavoro? (come visto da http://www.kernel.org/pub/software/scm/git/docs/git-revert.html)
    1. @Rod - Che suona bene, certo è una sintassi brutto anche se non lo è? ho sempre trovato il controllo della commit che voglio "ripristinare" e poi commettere che più intuitivo.
    1. @Lance Sono d'accordo con te su git revert --to - questo sembra un modo incredibilmente complesso per ottenere una cosa abbastanza semplice!
    1. c'è un modo molto più semplice per farlo ora che con uno script come questo, basta usare git revert --no-commit <start>..<end>, perché git revert accetta un intervallo di commit nuovo (o tutto?) versioni di Git. si noti che l'inizio dell'intervallo non è incluso nel revert.
  3. ho provato un sacco di modi per ripristinare i cambiamenti locali in Git, e sembra che questo funzioni meglio se vuoi tornare all'ultimo stato di commit.

    git add . && git checkout master -f
    

    breve descrizione:

    • non creerà nessun commit come fa git revert.
    • non si stacca il vostro HEAD come fa git checkout <commithashcode>.
    • sovrascriverà tutte le tue modifiche locali e DELETE tutti i file aggiunti dall'ultima commit nel ramo.
    • funziona solo con i nomi dei rami, in modo da poter ripristinare solo le ultime commit nel ramo in questo modo.

    ho trovato un modo molto più comodo e semplice per ottenere i risultati di cui sopra:

    git add . && git reset --hard HEAD
    

    dove HEAD punta all'ultima commit del tuo branch attuale.

    è lo stesso codice suggerito da boulder _ ruby, ma ho aggiunto git add . prima di git reset --hard HEAD per cancellare tutti i nuovi file creati dopo l'ultima commit dato che questo è quello che la maggior parte delle persone si aspettano che io creda quando torno all'ultima commit.

  4. ritorno alla copia di lavoro della commit più recente

    per ripristinare una commit precedente, ignorando qualsiasi modifica:

    git reset --hard HEAD
    

    dove HEAD è l'ultima commit nel tuo ramo attuale

    restituzione della copia di lavoro ad una vecchia commit

    per ripristinare una commit più vecchia della 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@
    git reset --hard HEAD
    
    git commit -m "Revert to 56e05fced" # Updates working copy to reflect the new commit git reset --hard

    i crediti vanno ad una domanda simile di Stack Overflow, Revert to a commit di un hash SHA in Git? ....

    1. l'ho fatto, ma poi non sono riuscito a fare commit e push sul repository remoto. voglio un vecchio commit specifico per diventare HEAD...
    1. significa che hai già inserito le commit che vuoi ripristinare. si può creare un sacco di problemi per le persone che hanno controllato il codice e lavorando su di esso. dal momento che non possono applicare il tuo commit senza intoppi su loro. in questo caso meglio fare un git revert. se sei l'unico che usa il repo. fai git push -f (ma pensa due volte prima di farlo)
    1. avviso Obbligatorio: non resettare duramente se stai condividendo il tuo branch con altre persone che hanno le copie delle vecchie commit, perché usando un reset così forzato dovrai risincronizzare il loro lavoro con il branch appena resettato. il soft reset è sicuro, però, così come le ultime soluzioni in questa risposta.
    1. voglio solo anche sottolineare che, in alternativa per la soluzione di reset soft, invece di fare un reset misto prima e un reset hard ultima, si può effettivamente fare il reset hard prima, come segue: git reset --hard 56e05fc; git reset --soft HEAD@git reset --hard 56e05fc; git reset --soft HEAD@{1}; git commit; git commit.
    1. se si sta lavorando in PowerShell, aggiungere citazioni intorno HEAD @:

      Git ripristina --soft 'HEAD @'

      perché le parentesi graffe hanno un significato

    1. @nuton Linus Pauling stesso, il creatore di git, criticato per essere troppo complicato. è su record dicendo che era "scioccato" git è diventato così popolare data la sua complessità
    1. @Goldname Fare solo il reset rigido funziona bene per locale, ma si rompe con i negozi remoti su GitHub. non sarà in grado di aggiornare senza un pull (che sconfigge lo scopo) a causa di essere dietro. la combinazione soft / hard reset è sicuramente il mio preferito in quanto risolve questo problema!
    1. @boulder_ruby Penso che tu abbia significato Linus Torvalds era il creatore di git. ma penso che Linus Pauling sarebbe probabilmente d'accordo che git è complicato.
  5. c'è un comando (non una parte del core Git, ma è nel pacchetto git-extra) specifico per il ripristino e la messa in scena di vecchie commit:

    git back
    

    per la pagina man, può anche essere utilizzato come tale:

    # Remove the latest three commits
    git back 3
    
  6. dopo tutte le modifiche, quando si preme tutti questi comandi, potrebbe essere necessario utilizzare:

    git push -f ...
    

    e non solo git push.

    1. attenzione Obbligatoria: non farlo se stai condividendo il tuo ramo con altre persone che hanno copie dei vecchi commit, perché usando una forza push come questa li costringerà a dover risincronizzare il loro lavoro. per una soluzione che spiega in dettaglio come ripristinare le commit senza perdere il lavoro con una forza push, vedi questa risposta.
    1. a volte questo è quello che vuoi. esempio: committed e push diverse commit nel ramo sbagliato (ramo A). dopo il cherry-picking al ramo B, voglio che questi commit vengano rimossi dal ramo A. Non voglio tornare, dato che il revert sarà poi applicato quando i rami A e B sono uniti insieme. fare un reset --hard nel ramo A seguito da una force push rimuove questi commit dal ramo pur conservandoli nel ramo B. Posso eliminare questo perché so che nessun altro si sta sviluppando nel ramo A.
    1. grazie!! non riuscivo a capire come ottenere il ramo remoto per abbinare il mio ramo locale, Basta avuto bisogno di fare un push forza.
  7. l'opzione migliore per me e probabilmente per altri è l'opzione di ripristino Git:

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

    questa è stata la migliore opzione per me! è semplice, veloce ed efficace!


    nota: come indicato nei commenti non farlo se stai condividendo il tuo ramo con altre persone che hanno copie delle vecchie commit

    anche dai commenti, se si voleva un metodo meno 'ballzy' si potrebbe usare

    git clean -i

    1. attenzione obbligatoria: non farlo se stai condividendo il tuo branch con altre persone che hanno le copie dei vecchi commit, perché usando un reset così forzato dovrai risincronizzare il loro lavoro con il branch appena reset. per una soluzione che spiega in dettaglio come ripristinare le commit senza perdere il lavoro con un hard reset, vedi questa risposta.
    1. i secondo avvertimento @Cupcake's... essere molto consapevoli delle conseguenze.

      nota, comunque, che se il tuo bisogno è davvero di far sparire quelle commit dalla storia per sempre, questo metodo reset + clean lo farà, e avrai bisogno di forza per spingere i tuoi branch modificati indietro a tutti i telecomandi.

    1. ricorda, clean rimuoverà file / cartelle come .idea (phpstorm) o .vagrant (vagrant) che possono essere usati dal tuo set up / IDE!
    1. @Pogrindis - un sacco di buone risposte su qui che non eliminare i file non tracciati.
    1. se usi "git clean -f" ti consiglio di verificare prima cosa eliminerai con: Git clean -f -n
    1. questo imposta la testa della mia copia locale alla commit desiderata. ma poi non posso spingere nessun cambiamento perché è dietro il telecomando. e se tiro dal telecomando finisce indietro dove era all'ultima commit sul ramo remoto.

      come faccio a cancellare completamente (da ogni dove) diversi commit sia sulla mia copia locale che sono stati spinti?

    1. @Ade.. Si potrebbe utilizzare il git push -f bandiera.. ma fate attenzione, supererà il telecomando.. Assicuratevi di sapere cosa si vuole fare...
    1. lavorato solo con clean -f. non ho dovuto salvare c'è ne del mio lavoro. né ho desiderato checkin tutta la cosa. volevo solo tornare ad una vecchia commit poiché la build stava passando allora.
  8. un sacco di risposte complicate e pericolose qui, ma in realtà è facile:

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

    questo farà tornare tutto dall'HEAD all'hash delle commit, il che significa che ricreerà lo stato delle commit nell'albero di lavoro come se ogni commit fosse stata rientrata. è quindi possibile commettere l'albero corrente, e creerà un commit nuovo di zecca essenzialmente equivalente al commit a cui "sei ritornato".

    (il flag --no-commit permette a git di ripristinare tutte le commit in once- altrimenti ti verrà richiesto un messaggio per ogni commit nell'intervallo, inserendo la cronologia con nuove commit non necessarie.)

    questo è un modo sicuro e facile per il rollback di uno stato precedente. nessuna storia viene distrutta, quindi può essere usata per commit che sono già stati resi pubblici.

    1. se si vuole veramente avere singole commit (invece di invertire tutto con una grande commit), allora si può passare --no-edit invece di --no-commit, in modo da non dover modificare un messaggio di commit per ogni reversione.
    1. se una delle commit tra 0766c053.. HEAD è una fusione, allora ci sarà un errore popping up (a che fare con nessun -m specificato). questo può aiutare coloro che incontrano che: http://stackoverflow.com/questions/5970889/why-does-git-revert-complain-about-a-missing-m-option
    1. Git newbie qui: sembra che se non puoi usare questo comando torni al commit più recente: ho un messaggio "commit vuoto". quindi devi impegnare il tuo ultimo lavoro e poi usare questo comando. mi chiedo se c'è un modo di reimpostare l'ultima commit?
    1. questo non ha aiutato; c'era una fusione e spuntato un errore dicendo -m opzione non specificata; Come nei commenti ho fatto questo git revert -m 1 HEAD, e provato di nuovo, ma ha dato un errore che dice cherrymick o revert è in corso. ho fatto cherrypick --quit, e tornò al messaggio che c'era una fusione e -m non è specificato
    1. ho appena controllato l'hash del commit e creato un nuovo ramo da lì a lavorare; Questo è più sicuro e più facile
    1. inoltre ho trovato che avevo bisogno di specificare il messaggio nella riga di comando usando -m "...." altrimenti avrebbe cercato di aprire VIM e non sarebbe in grado di salvare e avvitare tutto.
    1. $ git revert --no-commit 53742ae..HEAD restituisce fatal: empty commit set passed
    1. questa è la migliore risposta di questa domanda, mi aiuta a creare una commit dopo aver restituito il codice ad un albero diverso.
    1. in effetti, @Celeritas, il mio unico problema con Git (che altrimenti amo assolutamente) è che i singoli ritorni dopo una commit / push non avvertita sono orrendamente (logicamente) complessi da eseguire. solo una coppia di linee di comando, ma molto pericolose...: -)
    1. se non si vuole fare commit (basta ripristinare lo stato) si dovrebbe usare: git revert --no-edit 6e286400dbe..HEAD, git reset --hard 6e286400dbe in modo che il repo locale sarà ripristinato lo stato della commit 6e286400dbe
    1. @AlexG è perché è necessario inserire l'hash uno prima di quello che si desidera tornare a. nel mio caso, hash erano come: 81bcc9e HEAD{0}; e475924 HEAD81bcc9e HEAD{0}; e475924 HEAD{1}, ..., ... (da git reflog), e volevo annullare quello che ho fatto in 81bcc9e, poi ho dovuto fare git revert e475924..HEAD
    1. un sacco di risposte, un sacco di casi, ma mi frustra per vedere la gente chiama l'opzione "revert" più facile e sicuro. non lo è. sono due casi d'uso diversi. in qualsiasi repo con rami diversi - se si reimposta un ramo, il cambiamento finirà ovunque, anche nel ramo che si resetta (una volta che il ramo è coinvolto in un merge); se si ripristina un cambiamento, il cambiamento sarà infine eliminato ovunque, non solo questo ramo. se questo non è voluto, questo certamente non è sicuro.
    1. @Cookie - Non seguendo il tuo argomento, o cosa si intende con "se si ripristina un cambiamento, il cambiamento alla fine verrà eliminato ovunque". il vantaggio di utilizzare revert è che nulla viene eliminato, mentre con reset è. ecco perché è più sicuro.
    1. implementare funzionalità A nel ramo A. fonderli per padroneggiare. testarlo. fondere qualcos'altro. unire il ramo A nel rilascio. rendetevi conto che non avete voluto rilasciarlo ancora. ripristinare nella release. il rilascio è di nuovo buono. unire il rilascio alla caratteristica principale A è andato. unire il ramo A al master. unire qualsiasi cosa per padroneggiare. il relativo ancora andato. infine decidere di rilasciarlo. unire il ramo A per rilasciare. caratteristica A è ancora andato. e 'andato ovunque e l'unico modo per tornare indietro è quello di ciliegio scegliere tutti i commit o ripristinare i revers e il suo un dolore. non ripristinare quando è necessario ripristinare.
    1. a mio parere, l'approccio migliore a git revert --no-commit è git diff <commit-you-want-to-revert-to> > my-diff; patch -R -t -p1 < my-diff. questo approccio non ha il problema di -m option was given, e nessuna storia viene distrutta.
    1. questo genera un errore: error: commit d85f9b88d è un merge ma non è stata data alcuna opzione -m. fatale: il ritorno non è riuscito
    1. grazie per non essere un idiota senza mente e invece pubblicare una risposta USEFUL che funziona per la maggior parte degli scenari.
  9. seleziona la tua commit richiesta, e controllala

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

    finché non ottieni la commit richiesta. per fare il punto HEAD, fare

    git reset --hard HEAD~1
    

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

    1. attenzione obbligatoria: non farlo se stai condividendo il tuo branch con altre persone che hanno le copie dei vecchi commit, perché usando un reset così forzato dovrai risincronizzare il loro lavoro con il branch appena reset. per una soluzione che spiega in dettaglio come ripristinare le commit senza perdere il lavoro con un hard reset, vedi questa risposta.
  10. se vuoi "uncommit", cancellare l'ultimo messaggio di commit e rimettere in stage i file modificati, userai il comando:

    git reset --soft HEAD~1
    
    • --soft indica che i file non impegnati devono essere conservati come file di lavoro opposto a --hard che li scartare.
    • HEAD~1 è l'ultima commit. se vuoi effettuare il rollback 3 commit puoi usare HEAD~3. se vuoi tornare a un numero di revisione specifico, puoi farlo anche usando il suo hash SHA.

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

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

    1. questo è morbido e delicatamente: rischio libero se non hai spinto il tuo lavoro
  11. alternative extra alle soluzioni di Jefromi

    le soluzioni di Jefromi sono sicuramente le migliori, e si dovrebbe sicuramente usarli. tuttavia, per completezza, ho anche voluto mostrare queste altre soluzioni alternative che possono essere utilizzate anche per ripristinare una commit (nel senso che si crea una nuova commit che annulla i cambiamenti nella commit precedente, proprio come quello che git revert fa).

    per essere chiari, queste alternative non sono il modo migliore per ripristinare i commit, Jefromi soluzioni sono, ma voglio solo sottolineare che è anche possibile utilizzare questi altri metodi per raggiungere la stessa cosa come git revert.

    alternativa 1: reset duro e morbido

    questa è una versione leggermente modificata della soluzione di Charles Bailey al Revert to a commit di 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@
    git rm -r .
    git checkout <commit> .
    git commit
    
    # Commit the changes git commit -m "Revert to <commit>"

    questo fondamentalmente funziona usando il fatto che i reset soft lasceranno lo stato del commit precedente messo in scena nell'area index / staging, che si può poi commettere.

    alternativa 2: eliminare l'albero corrente e sostituire con il nuovo

    questa soluzione viene dalla soluzione di svick per Checkout vecchio commit e farne un nuovo commit:

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

    allo stesso modo dell'alternativa # 1, questo riproduce lo stato di <commit> nella copia corrente. è necessario fare git rm prima perché git checkout non rimuove i file che sono stati aggiunti da <commit>.

    1. a proposito di Alternative 1, una domanda rapida: così facendo non perdiamo tra le commit giuste?
    1. @Bogac - i punti indicano un percorso di file, in questo caso la directory corrente, quindi si presume che si sta eseguendo dalla radice della copia di lavoro.
    1. l'avvertimento viene ripetuto più volte nella risposta, ma qualcuno potrebbe aggiungere perché questi non sono il modo migliore - rispetto, a qualcosa come git revert HEAD~2..HEAD da @Cascabel's (@ Jefromi di) soluzione collegata. non vedo il problema.
  12. è possibile farlo con i seguenti due comandi:

    git reset --hard [previous Commit SHA id here]
    git push origin [branch Name] -f
    

    rimuoverà il tuo commit Git precedente.

    se vuoi mantenere le tue modifiche, puoi anche usare:

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

    poi salverà le modifiche.

    1. ho provato 1 / 2 una dozzina di risposte in questo post fino a quando non sono arrivato a questo. tutti gli altri, il mio git config continuava a darmi un errore quando si tenta di spingere. questa risposta ha funzionato. grazie!!
    1. un dettaglio per me era che ho perso i diffs.. che volevo continuare a vedere quello che avevo fatto nel commit che non funzionava. così la prossima volta vorrei solo salvare i dati prima di emettere questo comando di reset
    1. questo è stato l'unico modo per me per annullare una cattiva fusione, revert non ha funzionato in quel caso. grazie!!
  13. credo che alcune persone possono venire a questa domanda che vogliono sapere come rollback impegnati cambiamenti che hanno fatto nel loro maestro - cioè buttare tutto e tornare a origine / master, nel qual caso, fare questo:

    git reset --hard origin/master
    

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

  14. prima di rispondere aggiungiamo qualche background, spiegando cosa sia questo HEAD.

    First of all what is HEAD?

    HEAD è semplicemente un riferimento alla commit corrente (ultima) sul ramo corrente. ci può essere solo un singolo HEAD in un dato momento (escluso git worktree).

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


    detached HEAD

    se non sei sull'ultima commit - il che significa che HEAD punta ad una commit precedente nella storia si chiama detached HEAD.

    Enter image description here

    sulla riga di comando apparirà così - SHA-1 invece del nome del ramo dato che HEAD non punta alla punta del ramo corrente:

    Enter image description here


    alcune opzioni su come recuperare da un HEAD staccato:


    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 alla commit desiderata. questo comando farà il checkout di una determinata commit.

    a questo punto puoi creare un branch e iniziare a lavorare da questo punto su:

    # 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

    è sempre possibile utilizzare il reflog. git reflog visualizzerà qualsiasi cambiamento che ha aggiornato il HEAD e controllando la voce reflog desiderata imposterà il HEAD di nuovo a questa commit.

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

    git reflog
    git checkout HEAD@{...}
    

    questo ti riporterà alla commit desiderata

    Enter image description here


    git reset HEAD --hard <commit_id>

    "sposta" la tua testa indietro alla commit desiderata.

    # 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 si può vedere lì reset && checkout modificare il HEAD.

    Enter image description here

    1. suggerimento eccellente per git reflog, che è esattamente quello che mi serviva
    1. ouch!! tutto questo sembra terribilmente complicato... non c'è un semplice comando che ti fa solo un passo indietro nel processo? come andare dalla versione 1.1 nel vostro progetto alla versione 1.0? mi aspetto qualcosa come: Git fa un commit o qualcosa....
    1. @Kokodoko Sì, è orribilmente complicato... e un perfetto esempio di come gli esperti poca considerazione hanno per le persone che sono appena agli inizi. si prega di fare riferimento alla mia risposta qui, e anche al libro che vi consiglio. Git NON è qualcosa che puoi raccogliere intuitivamente. e posso essere assolutamente certo che CodeWizard non l'abbia fatto.
  15. non riuscivo a ripristinare il mio manualmente per qualche motivo, quindi ecco come ho finito per farlo.

    1. ho controllato il ramo che volevo avere, copiato.
    2. spuntato l'ultimo ramo.
    3. copiato il contenuto del branch ho voluto che l'ultima directory del branch sovrascriva i cambiamenti e li commettesse.
  16. se la situazione è urgente, e si vuole solo fare quello che il richiedente ha chiesto in modo rapido e sporco, supponendo che il progetto è sotto directory "il mio progetto":

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

    2. fare: fare:

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

    hai due versioni sul tuo sistema... puoi esaminare o copiare o modificare file di interesse, o qualsiasi altra cosa, dalla commit precedente. è possibile eliminare completamente i file in "il mio progetto - copia", se avete deciso che il nuovo lavoro stava andando da nessuna parte...

    la cosa ovvia se vuoi continuare con lo stato del progetto senza scartare il lavoro dato che questa commit recuperata è rinominare di nuovo la tua directory: eliminare il progetto contenente la commit recuperata (o darle un nome temporaneo) e rinominare la tua directory "my project - copy" in "my project". poi probabilmente fare un altro commit abbastanza presto.

    Git è una creazione brillante, ma non si può semplicemente "prenderla al volo": anche le persone che cercano di spiegarla troppo spesso assumono conoscenze precedenti di altri VCS [Version Control Systems] e si immergono troppo in profondità troppo presto, e commettono altri crimini, come usare termini intercambiabili per "check out" - in modi che a volte sembrano quasi calcolati per confondere un principiante.

    per risparmiare molto stress devi leggere un libro su Git - raccomanderei "Version Control with Git". e se ci si può fidare di me (o meglio le mie cicatrici) quando dico "devo", ne consegue che si potrebbe anche farlo ora. gran parte della complessità di Git viene dalla ramificazione e poi dalla fusione. ma dalla tua domanda non c "è ragione per cui le persone dovrebbero accecarti con la scienza.

    soprattutto se, per esempio, questa è una situazione disperata e sei un principiante con Git!

    PS: un altro pensiero: è (ora) abbastanza semplice tenere il repository Git ("repo") in una directory diversa da quella con i file di lavoro. questo significa che non dovrai copiare l'intero repository Git usando il precedente quick & amp; soluzione sporca. vedi la risposta di Fryer usando --separate-git-dir qui. attenzione, però: se hai un repository "separate-directory" che non copi, e fai un hard reset, tutte le versioni successive alla commit di reset saranno perse per sempre, a meno che tu non abbia, come assolutamente dovresti, regolarmente eseguito il backup del tuo repository, preferibilmente nel cloud (ad esempio Google Drive) tra gli altri luoghi.

  17. se vuoi correggere qualche errore nell'ultima commit, una buona alternativa è usare git commit --amend. se l'ultima commit non è indicata da alcun riferimento, questo farà il trucco, in quanto crea una commit con lo stesso genitore dell'ultima commit. se non c'è alcun riferimento all'ultima commit, questa sarà semplicemente scartata e questa commit sarà l'ultima. questo è un buon modo per correggere le commit senza annullare le commit. tuttavia ha i suoi limiti.

  18. per mantenere le modifiche dalla commit precedente a HEAD e passare alla commit precedente, fai:

    git reset <SHA>
    

    se le modifiche non sono richieste dalla commit precedente a HEAD e scartano tutte le modifiche, fai:

    git reset --hard <SHA>
    
  19. revert è il comando per eseguire il rollback delle commit.

    git revert <commit1> <commit2> 
    

    esempio: campione:

    git revert 2h3h23233

    è in grado di prendere portata dalla HEAD come sotto. qui 1 dice "revert last commit".

    git revert HEAD~1..HEAD

    e poi fare git push

  20. per ripulire completamente la directory di un coder da alcuni cambiamenti accidentali, abbiamo usato:

    git add -A .
    git reset --hard HEAD
    

    solo git reset --hard HEAD si sbarazzarsi di modifiche, ma non sbarazzarsi di "nuovi" file. nel loro caso hanno trascinato accidentalmente una cartella importante da qualche parte casuale, e tutti questi file sono stati trattati come nuovi da Git, quindi un reset --hard non lo ha corretto. eseguendo il git add -A . in anticipo, li ha tracciati esplicitamente tutti con git, da cancellare con il reset.

  21. ancora un'altra soluzione più semplice; devi cambiare ramo per farlo, ma dopo puoi semplicemente eseguire:

    git branch -f <<branchname>> 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
    
    1. AW uomo, perché la domanda del OP ha tante risposte diverse!? non dovrebbe tornare indietro essere un processo semplice?
    1. grazie!! questo metodo funziona su repo nudo ("git reset" ha bisogno di lavorare dir, quindi la maggior parte delle risposte qui non ha funzionato per me).
  22. ecco un modo molto più semplice per tornare ad un commit precedente (e averlo in uno stato non condiviso, per fare con esso quello che vuoi):

    git reset HEAD~1
    

    quindi, non c'è bisogno di commit id e così via:)

    1. non funziona, git pull dopo questo output: error: le tue modifiche locali ai seguenti file saranno sovrascritte da merge:
    1. @malhal Questo è perché hai avuto modifiche non commited. stash / reset e poi funzionerà senza quell'errore.
  23. questo è un altro modo per reimpostare direttamente una commit recente

    git stash
    git stash clear
    

    cancella direttamente tutti i cambiamenti che hai fatto dall'ultima commit.

    PS: ha un piccolo problema; elimina anche tutti i cambiamenti di scorta recentemente memorizzati. che credo nella maggior parte dei casi non dovrebbe importare.

    1. nota: i nuovi file non aggiunti nell'indice non vengono bloccati. hai anche aggiungerli o eliminarli manualmente.
    1. perché oh perché ripulire scorta? oltre ad essere una non-soluzione, questo è in realtà dannoso. la lettura della prima frase della domanda invalida immediatamente la soluzione stash (che potrebbe essere utile SOLO per il reset alla commit LAST).
  24. supponendo che si sta parlando di master e su quel ramo rispettivo (che ha detto, questo potrebbe essere 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 in un post sul blog (ora non esiste più)

    nota che questo è Reimpostare e Forzare il cambiamento nel telecomando, in modo che se altri membri del tuo team hanno già git tirato, tu causerai problemi per loro. stai distruggendo la storia del cambiamento, che è un motivo importante per cui la gente usa git in primo luogo.

    meglio usare revert (vedi altre risposte) che reset. se sei una squadra di un uomo allora probabilmente non importa.

    1. questo è un peccato. ho inviato la blogger - speriamo che lo abbia ancora!
    1. @Peter # brokenlink http://web.archive.org/web/20150411085146/http://lrotherfield.com/blog/delete-remote-git-repo-to-specific-commit
    1. la sintassi push è mancante dalla maggior parte degli altri suggerimenti su come risolvere questo problema. lavorato grande.
  25. ripristinare la commit più recente e ignorare tutte le modifiche locali:

    git reset --hard HEAD
    
  26. git reflog
    

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

    git reset HEAD@{12} --hard
    
  27. per il rollback (o per il revert):

    1. git revert --no-commit "commit-code-to-remove" HEAD (e.g. git revert --no-commit d57a39d HEAD)
    2. git commit
    3. git push

    prova sopra due passi, e se trovi questo è quello che vuoi allora git push.

    se si trova qualcosa di sbagliato fare:

    git revert --abort

  28. quando le tue commit vengono spinte da remoto, devi rimuoverle. supponiamo che il vostro ramo si sviluppi ed è spinto oltre origine.

    è necessario rimuovere prima sviluppare dall'origine:

    git push origin :develop (note the colon)
    

    poi è necessario ottenere sviluppare lo stato che si desidera, lasciatemi assumere l'hash commit è EFGHIJK:

    git reset --hard EFGHIJK
    

    infine, spingere sviluppare di nuovo:

    git push origin develop
    
  29. puoi completare tutti questi passi iniziali e tornare a git repo.

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

    2. eseguire il comando git log con -n 4 dal terminale. il numero dopo il -n determina il numero di commit nel log a partire dalla commit più recente nella tua storia locale.

      $ git log -n 4

    3. resettare la testa della cronologia del repository utilizzando il git reset --hard HEAD~N dove N è il numero di commit che si desidera prendere la testa indietro. nel seguente esempio il capo sarebbe stato riconsegnato un commit, all'ultimo commit nella storia del repository:

    4. invia la modifica a git repo usando git push --force per forzare la push della modifica.

    se vuoi git repository ad una commit precedente

    git pull --all
    git reset --hard HEAD~1
    git push --force
    
  30. in primo luogo, ottieni la stringa che identifica la commit in qualche data, facendo:

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

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

    git checkout XXXX
    
  31. prova a ripristinare la commit desiderata -

    git reset <COMMIT_ID>

    (per controllare l'uso di COMMIT _ ID git log)

    questo azzererà tutti i file cambiati in stato non aggiunto.

    ora è possibile checkout tutti i file non aggiunti da

    git checkout .

    controllare git log per verificare le modifiche apportate.

    aggiornamento aggiornamento aggiornamento aggiornamento

    se hai una sola commit nel tuo repo, prova

    git update-ref -d HEAD

  32. può essere fatto molto più facile con SourceTree. basta fare clic destro commit che stai cercando e scelto 'Checkout' dal menu.

    enter image description here

  33. OK, tornare alla commit precedente in git è abbastanza facile...

    ripristinare senza mantenere le modifiche:

    git reset --hard <commit>
    

    tornare indietro mantenendo le modifiche:

    git reset --soft <commit>
    

    spiegare: usando git reset, puoi reimpostare uno stato specifico, è comune usarlo con un hash delle commit come vedi sopra.

    ma come vedete la differenza sta usando i due flag --soft e --hard, per impostazione predefinita git reset usando --soft flag, ma è una buona pratica usare sempre il flag, spiego ogni flag:


    --morbido --morbido

    il flag di default, come spiegato, non è necessario fornirlo, non cambia l'albero di lavoro ma aggiunge tutti i file di modifiche pronti per la commit, quindi si torna allo stato della commit che le modifiche ai file non vengono messe in scena.


    --duro --duro

    fare attenzione con questo flag, ripristina l'albero di lavoro e tutte le modifiche ai file tracciati e tutto sarà andato!


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

    git reset to a commit

  34. se si desidera ripristinare temporaneamente le modifiche perché

    • qualcuno ha commesso il codice che la sua rottura di costruire o rompere la funzionalità si sta lavorando su

    puoi cercare l'ultima commit di lavoro usando git log quindi esegui

    git rebase --onto <commitId>
    

    quando il ramo remoto funziona di nuovo, puoi

    git pull --rebase
    

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

  35. il modo meno complicato per ripristinare un branch a una commit particolare dove non puoi cambiare la cronologia che ho trovato è:

    1. verifica la commit o il branch da cui vuoi tornare.
    2. modifica .git / HEAD e modifica la ref al ramo a cui vuoi ritornare.

    come ad esempio:

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

    se poi fai git status, dovresti vedere tutte le modifiche tra il ramo in cui sei e quello a cui vuoi tornare.

    se tutto sembra buono si può commettere. puoi anche usare git diff revert.. esempio per assicurarti che sia lo stesso.

  36. amo git, ma il fatto che ci siano 35 risposte a qualcosa che dovrebbe essere incredibilmente semplice espone un grosso problema con git. o è la documentazione?
  37. Caution! This command can cause losing commit history, if user put the wrong commit mistakenly. Always have en extra backup of your git some where else just in case if you do mistakes, than you are a bit safer. :)

    ho avuto un problema simile e volevo tornare a Commit precedente. nel mio caso non ero intetessed per mantenere più recente commit quindi ho usato Hard.

    ecco come l'ho fatto:

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

    questo tornerà sul repository locale, qui dopo aver usato git push -f aggiornerà il repository remoto.

    git push -f
    
  38. niente qui ha funzionato per me a parte questa combinazione esatta:

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

    chiave qui sta forzando il push, nessun messaggio extra commit / commit etc.

    1. questo ha funzionato per me, ma è necessario essere cura perché tutta la storia di commit dopo il duro reset sono persi e questa azione è irreversibile. dovete essere sicuri che cosa fate.
  39. su GitKraken puoi fare questo:

    1. clicca col tasto destro sulla commit che vuoi resettare, scegli: resettare a questa commit / Hard:

    enter image description here

    1. clicca di nuovo con il tasto destro del mouse sulla commit, scegli:

    enter image description here

    1. clicca sul pulsante di forza:

    enter image description here

    OBS. OBS. : devi essere attento perché tutta la storia della commit dopo il reset è persa e questa azione è irreversibile. dovete essere sicuri che cosa fate.

  40. ripristinare la commit più recente:

    git reset --hard HEAD
    

    HEAD è semplicemente un riferimento alla commit corrente (ultima) sul ramo corrente. ci può essere solo un singolo HEAD in un dato momento.

    ripristinare una vecchia commit: il modo più veloce per ripristinare una vecchia versione è usare il comando reset:

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

    questo riavvolgerà il ramo HEAD nella versione specificata. tutti i commit che sono arrivati dopo questa versione sono effettivamente disfatti; il tuo progetto è esattamente come era a quel punto nel tempo.

    il comando reset viene fornito con un paio di opzioni, una delle più interessanti è il flag --soft. se lo usi invece di --hard, Git manterrà tutte le modifiche delle commit "disfatte" come modifiche locali.

    ripristinare una revisione in un nuovo ramo locale

    come detto, usare il comando reset sul ramo HEAD è un'azione molto drastica: rimuoverà qualsiasi commit (su questo ramo) che è venuto dopo la revisione specificata. se sei sicuro che questo è quello che vuoi, tutto va bene.

    tuttavia, c'è anche un modo più sicuro nel caso in cui preferissi lasciare intatta la tua attuale diramazione HEAD. dato che i "rami" sono così economici e facili in Git, possiamo facilmente creare un nuovo ramo che parte da quella vecchia revisione:

    git checkout -b old-project-state 0ad5a7a6
    

    normalmente, il comando checkout viene usato per cambiare i rami. tuttavia, fornendo il parametro -b, si può anche lasciare che crei un nuovo ramo (chiamato vecchio progetto-stato in questo esempio). se non vuoi che inizi con l'attuale revisione HEAD, devi anche fornire un hash delle commit - la vecchia revisione del progetto che vogliamo ripristinare.

    ora hai un nuovo ramo chiamato vecchio progetto-stato che riflette la vecchia versione del tuo progetto - senza toccare o addirittura rimuovere altri commit o rami.

  41. reimpostazione Modifiche e commit

    il comando git reset ti permette di cambiare l'HEAD - l'ultima commit dei tuoi punti albero di lavoro al tuo repository. modifica l'area di messa in scena o l'area di messa in scena e l'albero di lavoro. la capacità di Git di eseguire commit esattamente come vuoi significa che a volte devi annullare le modifiche apportate con git add. è possibile farlo chiamando git reset HEAD <file to change>. avete due opzioni per sbarazzarsi di cambiamenti completamente. git checkout HEAD <file(s) or path(s)> è un modo rapido per annullare le modifiche all'area di stage e all'albero di lavoro. fare attenzione a questo comando, tuttavia, perché rimuove tutte le modifiche al vostro albero di lavoro. Git non sa di questi cambiamenti poiché non sono mai stati committati. non c'è modo di recuperare queste modifiche una volta eseguito questo comando. un altro comando a vostra disposizione è git reset --hard. e 'ugualmente distruttivo per il vostro albero di lavoro qualsiasi cambiamenti non impegnati o in stage cambiamenti vengono persi dopo averlo eseguito. eseguire git reset -hard HEAD fa la stessa cosa di git checkout HEAD. solo che non richiede un file o un percorso di lavoro. puoi usare --soft con git reset.It reimposta il repository alla commit specificata e mette in stage tutte queste modifiche. tutte le modifiche che avete già messo in scena non sono interessati, né sono le modifiche nella vostra tree.Finally di lavoro, è possibile utilizzare --mixed per ripristinare l'albero di lavoro senza mettere in scena eventuali modifiche.

    remando le commit

    a volte sbagliamo. un commit che non doveva essere condiviso viene inviato ad un repository pubblico, un commit ha un bug che non può essere corretto e deve essere annullato, o forse semplicemente non hai bisogno di quel codice più lungo. questi casi tutti richiedono il comando git revert. git revert fa proprio quello che ti puoi aspettare. inverte una singola commit applicando una commit inversa alla story.Sometimes devi ripristinare diverse commit per annullare completamente un cambiamento. puoi usare -no-commit, oppure puoi usare -n per dire a Git di eseguire il revert ma non fare il commit della modifica. questo ti permette di combinare tutte le commit di revert in una commit, che è utile se hai bisogno di ripristinare una caratteristica che abbraccia più commit. assicurati di ripristinare le commit in ordine inverso - prima la commit più recente. altrimenti, potresti confondere Git cercando di ripristinare codice che non esiste ancora.

  42. come è il linguaggio "trappola" nell'usare la parola per tornare come colloquialmente significato per ripristinare nemmeno Addressed qui??? 6594 voti up finora e non una modifica in questo modo, per sottolineare la differenza? non sarebbe più confuso riferirsi a "salvare un file" qui con l'espressione "commettere"...
  43. non ho visto usare cherry-pick:

    • commit A (reverse B)
    • commit B B

    cherry-pick A:

    • commit B B
    • commit A (reverse B)
    • commit B B

More similar articles:

  • come ripristinare il mio repository Github?
  • come ripristinare il repository Git per prima commit ed eliminare tutta la cronologia
  • ripristinare localmente il commit dal repository clonato/tutte le modifiche dopo il commit specifico
  • come spostare HEAD verso una posizione precedente? (testa staccata) & Annulla commit
  • come ripristinare un file in una versione precedente senza sovrascrivere le modifiche attuali?
  • come ripristinare la commit specifica di TILL in git
  • come usare 'git reset --hard HEAD' per tornare ad una commit precedente?
  • vai a una commit precedente, cambia e commetti come nuovo capo
  • come ripristinare le modifiche non committate, inclusi file e cartelle?
  • come ripristinare più git commit?
  • Git: come annullare il commit * e * ritornare all'ultimo branch
  • come ripristinare alcuni commit in Git senza creare patch reverse?
  • Git Checkout restituisce il codice a commit precedenti, come ripristinare?
  • rollback per un vecchio commit di Git in un repository pubblico
  • come ripristinare un commit automatico del sottoprogetto in git
  • come faccio a ripristinare una versione precedente come nuovo commit in Git?
  • come posso ripristinare i file specifici di una commit?
  • come ripristinare 3 git commit
  • annullare un particolare commit in Git che è stato spinto a repository remoti
  • come terminare il ripristino di una commit, e come ripristinare un sacco di commit
  • come ripristinare le ultime 2 commit fatte su Git
  • come ripristinare l'ultima commit e rimuoverla dalla cronologia?
  • ripristinare solo un singolo file di una commit push
  • in git, come ripristinare un file a 3 commit fa?
  • come posso ripristinare solo poche righe da un file registrato in una determinata commit?
  • come posso ripristinare il mio ramo ad una commit che ho creato durante la modalità detail-HEAD?
  • il pulsante revert di RStudio sembra agire come Git resettare
  • come ripristinare parte di una commit?
  • ripristinare il ramo spinto ad una commit concreta
  • come annullare l'ultima commit in git