Come faccio a riportare un repository Git a un precedente commettere?

https://stackoverflow.com/questions/4114095

29-09-2019
|

Domanda

Come faccio Ripristina dal mio attuale stato di un'istantanea fatta su un certo impegno?

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 fare Ripristina il commit dal 3 novembre, vale a dire commettere 0d1d7fc?

Soluzione

Questo dipende molto da cosa si intende per "Ripristina".

temporaneamente passare a un diverso commit

Se si vuole andare momentaneamente di nuovo esso, scherzare, per poi tornare al punto in cui ti trovi, tutto ciò che dovete fare è controllare la desiderata commit:

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

Se si vuole fare commit mentre sei lì, andare avanti e fare un nuovo ramo mentre si è in esso:

git checkout -b old-state 0d1d7fc32

Per tornare dove eravate, basta controllare il ramo che eri di nuovo. (Se hai apportato delle modifiche, come sempre quando si passa rami, avrete a che fare con loro a seconda dei casi Si potrebbe ripristinare buttarli via,. Si può riporre, checkout, scorta pop di portarli con voi, si potrebbe commettere loro di un ramo se volete una succursale.)

Hard eliminare inedito commit

Se, d'altra parte, si vuole ottenere davvero liberarsi di tutto ciò che hai fatto da allora, ci sono due possibilità. Uno, se non avete pubblicato uno di questi commit, basta 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 fa confusione, hai già buttato via le modifiche locali, ma si può almeno tornare a dove eravate prima reimpostando di nuovo.

Annulla commit pubblicati con i nuovi commit

D'altra parte, se hai pubblicato il lavoro, probabilmente non si vuole azzerare il ramo, dal momento che è effettivamente riscrivere la storia. In tal caso, si potrebbe infatti tornare i commit. Con Git, ripristinare ha un significato molto specifico: creare un commit con il cerotto inverso per cancellarlo. In questo modo non si riscrive 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 git-revert manpage in realtà copre un sacco di questo nella sua descrizione. Un altro link utile è questo git-scm.com sezione discute git -revert .

Se si decide di non volevi tornare dopo tutto, è possibile ripristinare il revert (come descritto qui) o ripristinare indietro a prima del revert (vedere la sezione precedente).

Si può anche trovare utile questa risposta, in questo caso:
Come tornare HEAD a una posizione precedente? (Testa Indipendente)

Altri suggerimenti

Un sacco di risposte complicato e pericoloso qui, ma in realtà è semplice:

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

Questa tornerà tutto da dietro la testa al hash commit, il che significa che ricreerà che commettono Stato nella albero di lavoro come se ogni commit da quando era stato tornò indietro. È quindi possibile commettere l'albero corrente, e creerà un nuovo marchio di impegnarsi sostanzialmente equivalente alla commettere voi "conversione" a.

(La bandiera --no-commit consente Ripristina git tutti i commit a una volta-altrimenti ti verrà richiesto per un messaggio per ogni impegnarsi nella gamma, sporcare la vostra storia con inutili nuovi commit.)

Questo è un modo sicura e facile da rollback a uno stato precedente . Nessuna cronologia viene distrutto, in modo che possa essere utilizzato per commit che sono già stati resi pubblici.

Rogue Coder?

di lavoro da soli e solo vogliono che il lavoro? Seguire le istruzioni qui di seguito, hanno lavorato in modo affidabile per me e molti altri per anni.

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

Se ripristini di lavoro Copia Più recente Commit

Per ripristinare un precedente commit, ignorando tutte le modifiche:

git reset --hard HEAD

dove HEAD è l'ultimo commit nel ramo corrente

Ripristino della copia di lavoro a un vecchio Commit

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

# 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

Credits andare a una simile domanda Stack Overflow, Ripristina ad un commit da un hash SHA in Git? .

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

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

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

Nota: Come accennato nei commenti non farlo se si sta condividendo il vostro ramo con altre persone che hanno copie dei vecchi commit

Anche dai commenti, se si voleva un metodo meno 'Ballzy' si potrebbe usare

git clean -i

Prima di rispondere andiamo aggiungere un po 'di sfondo, spiegando che cosa questo HEAD è.

`First of all what is HEAD?`

HEAD è semplicemente un riferimento alla corrente commit (l'ultima) sul ramo corrente. Ci può essere solo un singolo HEAD in un dato momento (ad esclusione git worktree).

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

`detached HEAD`

Se non si è sulle ultime commit -. Il che significa che HEAD sta puntando ad una precedente commit nella storia si chiama detached HEAD

Nella riga di comando che sarà simile a questa - SHA-1 invece del nome del ramo in quanto il HEAD non punta alla punta del ramo corrente:

Un paio di opzioni su come recuperare da una testa staccata:

`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 checkout nuova punta ramo desiderato commettere. Questo comando checkout a un determinato commit.

A questo punto è possibile 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`

È sempre possibile utilizzare il reflog pure. git reflog visualizzerà tutte le modifiche che ha aggiornato l'HEAD e controllando la voce desiderata reflog imposterà la schiena HEAD a questo commit.

Ogni volta che la testa è modificato ci sarà una nuova voce nel reflog

git reflog
git checkout HEAD@{...}

Questo ti porterà di nuovo al vostro desiderato commettere

`git reset HEAD --hard <commit_id>`

"Move" la schiena testa al desiderato commettere.

# 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 ) è anche possibile utilizzare il git rebase --no-autostash pure.

Questo schema illustra che il comando fa quello. Come potete vedere ci reset && checkout modificare la HEAD.

Se si vuole "uncommit", cancellare l'ultimo messaggio di commit, e mettere i file modificati nel messa in scena, si può usare il comando:

git reset --soft HEAD~1

--soft indica che i file non impegnati devono essere conservati come file di lavoro opposte a --hard che li scartare.
HEAD~1 è l'ultimo commit. Se si desidera eseguire il rollback 3 commit è possibile utilizzare HEAD~3. Se si desidera eseguire il rollback a un numero specifico di revisione, si potrebbe anche farlo utilizzando il suo hash SHA.

Questo è un comando estremamente utile in situazioni in cui avete commesso la cosa sbagliata e si desidera annullare tale ultimo commit.

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

Ho provato un sacco di modi per annullare le modifiche locali in Git, e sembra che questo funziona meglio se si desidera solo per ripristinare l'ultimo stato commit.

git add . && git checkout master -f

Breve descrizione:

Non sarà creare alcun commit come git revert fa.
Non sarà staccare la testa come git checkout <commithashcode> fa.
Si avrà la precedenza su tutte le modifiche locali ed eliminare tutti i file aggiunti dall'ultimo commit nel ramo.
Funziona solo con i nomi di rami, in modo da poter tornare solo per ultimo commettere nel ramo questo modo.

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

git add . && git reset --hard HEAD

dove i punti testa per l'ultima impegnano a voi ramo corrente.

E 'lo stesso codice di boulder_ruby suggerito, ma ho aggiunto git add . prima git reset --hard HEAD per cancellare tutti i nuovi file creati dall'ultima commit dal momento che questo è ciò che la maggior parte delle persone si aspettano Credo che quando ritornando all'ultima commesso.

Si può fare questo con i seguenti due comandi:

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

Sarà rimuovere il precedente git commit.

Se si desidera mantenere le modifiche, è anche possibile utilizzare:

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

Poi sarà salvare le modifiche.

OK tornare al precedente commit in Git è abbastanza facile ...

tornare senza tenere le modifiche:

git reset --hard <commit>

tornare con il mantenimento le modifiche:

git reset --soft <commit>

Spiegare: utilizzando ripristino git, è possibile ripristinare ad uno stato specifico, è comune utilizzarlo con un commettere hash come vedete sopra.

Ma, come si vede la differenza sta usando il --soft due bandiere e --hard, per impostazione predefinita git reset utilizzando bandiera --soft, ma si tratta di una buona pratica di utilizzare sempre la bandiera, spiego ogni bandiera:

- morbido

Il flag di default, come spiegato, non c'è bisogno di fornire, non cambia l'albero di lavoro, ma aggiungere tutte le modifiche dei file pronti ad impegnarsi, in modo da andare di nuovo alla condizione che le modifiche ai file non è stato classificato ottenere commettere.

- difficile

Fare attenzione con questo flag, reimposta 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 che lavora con git:

Supponendo che si sta parlando di master e su quello rispettivo ramo (che ha detto, questo potrebbe essere una qualsiasi filiale di lavoro sei preoccupato con):

# 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ù)

Si noti che questo è Ripristino e Forzare il cambiamento al telecomando, in modo che se altri membri del team hanno già tirato git, che riuscirai a causare problemi per loro. Si sta distruggendo la cronologia delle modifiche, che è un motivo importante per cui la gente usa git, in primo luogo.

meglio usare revert (vedi altre risposte) di reset. Se sei un team di un uomo allora probabilmente non importa.

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 costringendo la spinta, non commit supplementari / commit messaggi ecc.

Diciamo che hanno i seguenti commit in un file di testo denominato ~/commits-to-revert.txt (io ho usato git log --pretty=oneline di farli)

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

Bash script di shell per tornare 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 torna allo stato precedente, tra cui file e la creazione di directory, e le eliminazioni, si impegnano al vostro ramo e di conservare la storia, ma lo avete ritornato di nuovo alla stessa struttura di file. Perché Git non ha un git revert --to <hash> è oltre me.

Alternative in più per soluzioni di Jefromi

Jefromi sono sicuramente i migliori, e si dovrebbe assolutamente usarli. Tuttavia, per ragioni di completezza, ho anche voluto mostrare queste altre soluzioni alternative che possono anche essere utilizzati per ripristinare un commit (nel senso che si Crea un nuovo commit che annulla modifiche nelle precedenti commettono , proprio come quello che git revert fa).

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

Alternativa 1: hard e soft Reset

Questa è una versione molto leggermente modificata di soluzione di Charles Bailey su Ripristina ad un commettere 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 praticamente utilizzando il fatto che ripristina morbide lascerà lo stato della precedente commit in scena nell'indice / staging area, che si può quindi eseguire il commit.

Alternativa 2: eliminare la struttura corrente e sostituirlo con quello nuovo

Questa soluzione viene dalla soluzione di svick a Acquista vecchio impegnarsi e lo rendono una nuova commettere :

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

Analogamente alternativa # 1, questo riproduce lo stato della <commit> nella copia di lavoro corrente. E 'necessario fare in primo luogo perché git rm git checkout non rimuoverà i file che sono stati aggiunti dopo <commit>.

Ecco un molto più semplice modo per tornare indietro ad un precedente commettere (e l'abbiano in uno stato UNCOMMITED, a che fare con essa quello che vuoi):

git reset HEAD~1

Quindi, non c'è bisogno di impegnarsi ids e così via:)

C'è un comando (non una parte di nucleo Git, ma è nel pacchetto href="https://github.com/visionmedia/git-extras"> ) specificamente per un ritorno e messa in scena vecchi commit:

git back

Per la , può essere utilizzato anche come tale:

# Remove the latest three commits
git back 3

Dopo tutti i cambiamenti, quando si spinge tutti questi comandi, potrebbe essere necessario utilizzare:

git push -f ...

E non solo git push.

È possibile completare tutti questi passi iniziali se stessi e di nuovo spinta per repo git.

Tirare la versione più recente del repository da Bitbucket utilizzando il git pull --all comando.
Eseguire il comando git log con -n 4 dal vostro terminale. Il numero dopo la -n determina il numero di commit nel registro a partire dalla più recente impegnarsi nella vostra storia locale.

$ git log -n 4
Ripristina il capo della cronologia del vostro repository utilizzando il git reset --hard HEAD~N dove N è il numero di commit si desidera prendere parte posteriore della testa. Nel seguente esempio la testa sarebbe insieme uno indietro impegnarsi, fino all'ultimo commit nella storia repository:
Spingere la modifica repo git utilizzando git push --force alla forza di spinta la modifica.

Se si desidera repository git ad un commit precedente

git pull --all
git reset --hard HEAD~1
git push --force

Ripristina più recente commit e ignorando tutte le modifiche locali:

git reset --hard HEAD

Seleziona il tuo necessario impegnarsi, e controllare che da

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

fino ad ottenere il richiesto commettere. Per fare il punto HEAD a questo, fare

git reset --hard HEAD~1

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

Per mantenere le modifiche dal precedente impegnano a HEAD e passare al precedente commettere, fare:

git reset <SHA>

Se le modifiche non sono necessarie dal precedente impegnarsi a HEAD e rinunciate a tutte le modifiche, fare:

git reset --hard <SHA>

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

git add -A .
git reset --hard HEAD

Proprio git reset --hard HEAD sarà sbarazzarsi di modifiche, ma non sarà sbarazzarsi di "nuovi" i file. Nel loro caso avevano accidentalmente trascinato una cartella importante da qualche parte casuale, e tutti i file sono stati trattati come nuovi da Git, quindi un reset --hard non risolvere il problema. Eseguendo il git add -A . in anticipo, ma tutti monitorati in modo esplicito con git, per essere spazzato via dal reset.

Questo è un altro modo per ripristinare direttamente ad una recente commit

git stash
git stash clear

Si cancella direttamente tutte le modifiche che avete fatto fin l'ultimo commit.

PS: Ha un piccolo problema; ma elimina anche tutti voi le modifiche Stash recentemente memorizzati. Che immagino nella maggior parte dei casi non dovrebbe importare.

Credo che alcune persone possono venire a questa domanda che vogliono sapere come eseguire il rollback modifiche impegnati che hanno fatto nella loro padrone - vale a dire tutto ciò che buttare via e tornare alle origini / master, nel qual caso, procedere come segue:

git reset --hard origin/master

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

Se la situazione è un urgente , e si vuole solo fare quello che l'interrogante ha chiesto in un in modo rapido e sporco, supponendo che il progetto è in fase di directory "il mio progetto ":

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

Do:

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

A questo punto avete due versioni sul vostro sistema ... è possibile esaminare o copiare o modificare i file di interesse, o qualsiasi altra cosa, dal precedente commit. Puoi scartare completamente i file sotto "il mio progetto - copia", se avete deciso il nuovo lavoro stava andando da nessuna parte ...

La cosa ovvia se si vuole portare avanti con lo stato del progetto senza realmente scartare il lavoro dal momento che questo recuperate commettere è quello di rinominare nuovamente la directory: Eliminare il progetto contenente il recuperati commit (o dare un nome temporaneo) e rinominare il "mio progetto - copia" back directory a "il mio progetto". Allora probabilmente fare un altro commit abbastanza presto.

Git è una creazione brillante ma non si può semplicemente "prenderlo al volo": anche le persone che cercano di spiegare che troppo spesso assumere la conoscenza preventiva di altri VCS [sistemi di controllo versione ] e approfondire troppo in profondità troppo presto, e commettere altri crimini, come l'utilizzo di termini intercambiabili per "check-out" - in modi che a volte sembrano quasi calcolati per confondere un principiante.

Per salvare se stessi molto stress si deve praticamente dover leggere un libro su Git - mi consiglia di " controllo di Versione con Git ". E se ci si può fidare di me (o meglio le mie cicatrici) quando dico "devono", ne consegue che si potrebbe anche farlo ora . Gran parte della complessità del Git viene dalla ramificazione e poi remerging. Ma dalla tua domanda c'è alcun motivo per cui la gente si dovrebbe essere accecante con la scienza .

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

PS: Un altro pensiero: è (ora) in realtà abbastanza semplice per mantenere il repository Git ( "pronti contro termine") in una directory diversa da quella con i file di lavoro. Ciò significa che non avrebbe dovuto copiare l'intero repository Git utilizzando il sopra rapida e soluzione sporca. Vedi la risposta da Fryer utilizzando --separate-git-dir qui . Attenzione , però: se si dispone di un repository "separata-directory", che non copi, e fare un hard reset, tutte le versioni successive per il reset commit saranno persi per sempre, a meno che non dispone, come è assolutamente necessario, sostenuto regolarmente il proprio repository, preferibilmente al cloud (ad esempio Google drive ) tra gli altri luoghi.

Su questo argomento di "backup su the Cloud", il passo successivo è quello di aprire un account (gratuito ovviamente) con GitHub o (meglio a mio avviso) GitLab. È quindi possibile fare regolarmente un comando git push per eseguire il backup dei pronti contro termine Cloud "correttamente". Ma ancora una volta, a parlare di questo potrebbe essere troppo e troppo presto.

Ripristina è il comando per eseguire il rollback i commit.

git revert <commit1> <commit2>

Esempio:

git revert 2h3h23233

E 'in grado di prendere vanno dalla testa come di seguito. Qui 1 dice "Ripristina ultima commesso."

git revert HEAD~1..HEAD

e poi fare git push

Ripristina Più recente Commit:

git reset --hard HEAD

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

Ripristina a un vecchio commit: Il modo più veloce per ripristinare una vecchia versione è quello di usare 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 riavvolgere il ramo HEAD alla versione specificata. Tutti i commit che è venuto dopo questa versione sono effettivamente annullate; il progetto è esattamente come era a quel punto nel tempo.

Il comando di ripristino viene fornito con un paio di opzioni, una delle più interessanti che sono la bandiera --soft. Se si utilizza invece di --hard, Git manterrà tutti i cambiamenti in quelle commit "annullate" come modifiche locali.

Ripristino di una revisione in un Nuova filiale locale

Come ha detto, utilizzando il comando di reset sul ramo HEAD è un'azione piuttosto drastica: esso consente di eliminare ogni commit (su questo ramo) che è venuto dopo la revisione specificato. Se sei sicuro che questo è ciò che si vuole, è tutto a posto.

Tuttavia, c'è anche un sicura modo nel caso in cui si preferisce lasciare la vostra filiale attuale capo intatto. Dal momento che "rami" sono così a buon mercato e facile in Git, si può facilmente creare un nuovo ramo che inizia in quel vecchio di revisione:

git checkout -b old-project-state 0ad5a7a6

Normalmente, il comando cassa viene utilizzato per soli rami di commutazione. Tuttavia, fornendo il parametro -b, si può anche lasciare che creare un nuovo ramo (denominato vecchio progetto di stato in questo esempio). Se non si desidera che venga avviato alla revisione HEAD corrente, è inoltre necessario fornire un commit hash - la vecchia versione del progetto vogliamo ripristinare

Si hanno ora una nuova filiale denominata vecchio progetto di stato che riflette la vecchia versione del progetto -. Senza toccare o anche la rimozione di qualsiasi altro commit o rami

Prova a reimpostare il desiderato impegno -

git reset <COMMIT_ID>

(per controllare COMMIT_ID uso git log)

In questo modo ripristinare tutti i file modificati a stato-un ha aggiunto.

Ora è possibile checkout tutti i file-un inserito da

git checkout .

Controlla git log per verificare le modifiche.

Aggiorna

Se si dispone di unico e solo commit nel pronti contro termine, provare

git update-ref -d HEAD

Mentre i vostri commit sono spinti da remoto, è necessario rimuoverli. Lasciatemi Presumo vostra filiale è di sviluppare ed è spinto oltre origine.

Per prima cosa è necessario rimuovere sviluppare di origine:

git push origin :develop (note the colon)

Quindi è necessario per ottenere sviluppare per lo stato desiderato, mi lasci assumo il commit hash è EFGHIJK:

git reset --hard EFGHIJK

Infine, spingere lo sviluppo di nuovo:

git push origin develop

Attenzione! Questo comando può causare perdita di commettere storia, se l'utente ha messo dalla parte del torto impegnarsi per errore. Hanno sempre en il backup in più del vostro qualche git dove altro nel caso in cui se si fa errori, di quello che sei un po 'più sicuro. :)

ho avuto problema simile e voleva tornare al precedente Commit. Nel mio caso non ero intetessered per mantenere più recente commettere di conseguenza ho Hard utilizzato.

Ecco come ho fatto:

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

Verrà ripristinata sul deposito locale, qui dopo usando git push -f aggiornerà repository remoto.

git push -f

Se si desidera correggere un errore nell'ultimo commettono una buona alternativa sarebbe utilizzando git commit Comando --amend. Se l'ultimo commit non è puntato da qualsiasi riferimento, questo farà il trucco, in quanto crea un commit con lo stesso genitore come l'ultimo commit. Se non v'è alcun riferimento all'ultimo commit, sarà semplicemente essere scartata e questo commit sarà l'ultimo commit. Questo è un buon modo di correggere commit senza ritornare commit. Tuttavia ha i suoi limiti.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow