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
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:
o se vuoi fare commit mentre sei lì, vai avanti e crea un nuovo branch mentre sei lì:
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:
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.
il manuale
git-revertin 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)
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 poigit adding egit commiting tutto per padroneggiare. dopo di che ho cancellato il nuovo (ma temporaneo) ramo.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.)git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50git push origin masterdopo revert.git revert HEAD~2..HEAD. succede.........git stash && git reset --hard && git stash pop? non sarebbegit reset 0d1d7fc32raggiungere lo stesso?--mixedè di default perreset, che lascia l'albero di lavoro fuori scena come prima del reset.git checkout -b old-state 0d1d7fc32git checkout 0d1d7fc32 -b old-stateinvece?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.git clean -f -d -nper vedere quali file non sono tracciati, egit clean -f -dper eliminarli.git tag -d some-tag-namegit checkout mastergit reset --mixed.git checkout -o il nome del ramo esplicito come 'master'".è importante - dirige git per controllare lo stato da 0d1d7fc32 nella directory corrente, ma lascia HEAD dove si trovava. e 'lo stesso che usare qualcosa comegit 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..è un percorso.git checkoutriguardante 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."git checkout <branch> <path>, non passa a quel ramo, e se si fagit checkout <commit> <path>non staccare HEAD passando a quella commit.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?git branch -D fool_aroundCome funziona quando torno a un commit precedente e giro in giro?git push -f origin masterper correggere remoto dopo aver risolto locale.git push origin masterma 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.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/119963force. 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?git checkout -b old-state 0d1d7fc32mi dà un errorefatal: Cannot update paths and switch to branch 'oldApi' at the same time.Ho dovuto farlo separatamente prima chiamandogit checkout 0d1d7fc32e poigit checkout -b old-state.git revert HEAD?dire di avere le seguenti commit in un file di testo chiamato
~/commits-to-revert.txt(ho usatogit log --pretty=onelineper ottenerle)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 donequesto 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.git revert HEAD~3per rimuovere le ultime 3 commitgit revert -n master~3..master~1lavoro? (come visto da http://www.kernel.org/pub/software/scm/git/docs/git-revert.html)git revert --no-commit <start>..<end>, perchégit revertaccetta un intervallo di commit nuovo (o tutto?) versioni di Git. si noti che l'inizio dell'intervallo non è incluso nel revert.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.
breve descrizione:
git revert.git checkout <commithashcode>.ho trovato un modo molto più comodo e semplice per ottenere i risultati di cui sopra:
dove HEAD punta all'ultima commit del tuo branch attuale.
è lo stesso codice suggerito da boulder _ ruby, ma ho aggiunto
git add .prima digit reset --hard HEADper 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.ritorno alla copia di lavoro della commit più recente
per ripristinare una commit precedente, ignorando qualsiasi modifica:
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:
i crediti vanno ad una domanda simile di Stack Overflow, Revert to a commit di un hash SHA in Git? ....
git reset --hard 56e05fc; git reset --soft HEAD@.git reset --hard 56e05fc; git reset --soft HEAD@{1}; git commit; git commitGit ripristina --soft 'HEAD @'
perché le parentesi graffe hanno un significato
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:
per la pagina man, può anche essere utilizzato come tale:
dopo tutte le modifiche, quando si preme tutti questi comandi, potrebbe essere necessario utilizzare:
e non solo
git push.l'opzione migliore per me e probabilmente per altri è l'opzione di ripristino Git:
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 -inota, 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.
pericolo di pericolo
come faccio a cancellare completamente (da ogni dove) diversi commit sia sulla mia copia locale che sono stati spinti?
git push -fbandiera.. ma fate attenzione, supererà il telecomando.. Assicuratevi di sapere cosa si vuole fare...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.un sacco di risposte complicate e pericolose qui, ma in realtà è facile:
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-commitpermette 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.
--no-editinvece di--no-commit, in modo da non dover modificare un messaggio di commit per ogni reversione.git diff --cached.-m "...."altrimenti avrebbe cercato di aprire VIM e non sarebbe in grado di salvare e avvitare tutto.$ git revert --no-commit 53742ae..HEADrestituiscefatal: empty commit set passedgit revert --no-edit 6e286400dbe..HEAD,git reset --hard 6e286400dbein modo che il repo locale sarà ripristinato lo stato della commit6e286400dbe81bcc9e HEAD{0}; e475924 HEAD(da81bcc9e HEAD{0}; e475924 HEAD{1}, ..., ...git reflog), e volevo annullare quello che ho fatto in81bcc9e, poi ho dovuto faregit revert e475924..HEADgit 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.seleziona la tua commit richiesta, e controllala
finché non ottieni la commit richiesta. per fare il punto HEAD, fare
o
git reset --hard HEAD~2o qualsiasi altra cosa.git show HEADequivale a usare sologit log HEAD -1.se vuoi "uncommit", cancellare l'ultimo messaggio di commit e rimettere in stage i file modificati, userai il comando:
--softindica che i file non impegnati devono essere conservati come file di lavoro opposto a--hardche li scartare.HEAD~1è l'ultima commit. se vuoi effettuare il rollback 3 commit puoi usareHEAD~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/
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 revertfa).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? ::::
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:
allo stesso modo dell'alternativa # 1, questo riproduce lo stato di
<commit>nella copia corrente. è necessario faregit rmprima perchégit checkoutnon rimuove i file che sono stati aggiunti da<commit>.git revert HEAD~2..HEADda @Cascabel's (@ Jefromi di) soluzione collegata. non vedo il problema.è possibile farlo con i seguenti due comandi:
rimuoverà il tuo commit Git precedente.
se vuoi mantenere le tue modifiche, puoi anche usare:
poi salverà le modifiche.
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:
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 singoloHEADin un dato momento (esclusogit worktree).il contenuto di
HEADè memorizzato all'interno di.git/HEAD, e contiene i 40 byte SHA-1 della commit corrente.detached HEADse non sei sull'ultima commit - il che significa che
HEADpunta ad una commit precedente nella storia si chiamadetached HEAD.sulla riga di comando apparirà così - SHA-1 invece del nome del ramo dato che
HEADnon punta alla punta del ramo corrente:alcune opzioni su come recuperare da un HEAD staccato:
git checkoutquesto 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:
git reflogè sempre possibile utilizzare il
reflog.git reflogvisualizzerà qualsiasi cambiamento che ha aggiornato ilHEADe controllando la voce reflog desiderata imposterà ilHEADdi nuovo a questa commit.ogni volta che l'HEAD viene modificato ci sarà una nuova voce nel
refloggit reflog git checkout HEAD@{...}questo ti riporterà alla commit desiderata
git reset HEAD --hard <commit_id>"sposta" la tua testa indietro alla commit desiderata.
git rebase --no-autostash.questo schema illustra quale comando fa cosa. come si può vedere lì
reset && checkoutmodificare ilHEAD.git reflog, che è esattamente quello che mi servivagit reset HEAD^--hard 'non riuscivo a ripristinare il mio manualmente per qualche motivo, quindi ecco come ho finito per farlo.
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":
copiare l'intera directory e chiamare qualcos'altro, come "il mio progetto - copia"
fare: fare:
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.
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.
per mantenere le modifiche dalla commit precedente a HEAD e passare alla commit precedente, fai:
se le modifiche non sono richieste dalla commit precedente a HEAD e scartano tutte le modifiche, fai:
revert è il comando per eseguire il rollback delle commit.
esempio: campione:
git revert 2h3h23233è in grado di prendere portata dalla HEAD come sotto. qui 1 dice "revert last commit".
git revert HEAD~1..HEADe poi fare
git pushper ripulire completamente la directory di un coder da alcuni cambiamenti accidentali, abbiamo usato:
solo
git reset --hard HEADsi 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 unreset --hardnon lo ha corretto. eseguendo ilgit add -A .in anticipo, li ha tracciati esplicitamente tutti con git, da cancellare con il reset.ancora un'altra soluzione più semplice; devi cambiare ramo per farlo, ma dopo puoi semplicemente eseguire:
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):
quindi, non c'è bisogno di commit id e così via:)
questo è un altro modo per reimpostare direttamente una commit recente
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.
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):
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.
ripristinare la commit più recente e ignorare tutte le modifiche locali:
scegli il numero di HEAD (s) di git reflog, dove vuoi tornare e fare (per questo esempio scelgo il 12):
git reset HEAD@{12} --hardper il rollback (o per il revert):
prova sopra due passi, e se trovi questo è quello che vuoi allora git push.
se si trova qualcosa di sbagliato fare:
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:
poi è necessario ottenere sviluppare lo stato che si desidera, lasciatemi assumere l'hash commit è EFGHIJK:
infine, spingere sviluppare di nuovo:
puoi completare tutti questi passi iniziali e tornare a git repo.
estrarre l'ultima versione del repository da Bitbucket usando il comando
git pull --all.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 4resettare la testa della cronologia del repository utilizzando il
git reset --hard HEAD~Ndove 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:invia la modifica a git repo usando
git push --forceper forzare la push della modifica.se vuoi git repository ad una commit precedente
in primo luogo, ottieni la stringa che identifica la commit in qualche data, facendo:
stampa l'identificatore di commit, prendi la stringa (per esempio XXXX) e fai:
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
checkouttutti i file non aggiunti dagit checkout .controllare
git logper verificare le modifiche apportate.aggiornamento aggiornamento aggiornamento aggiornamento
se hai una sola commit nel tuo repo, prova
git update-ref -d HEADpuò essere fatto molto più facile con SourceTree. basta fare clic destro commit che stai cercando e scelto 'Checkout' dal menu.
OK, tornare alla commit precedente in git è abbastanza facile...
ripristinare senza mantenere le modifiche:
tornare indietro mantenendo le modifiche:
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
--softe--hard, per impostazione predefinitagit resetusando--softflag, 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:
se si desidera ripristinare temporaneamente le modifiche perché
puoi cercare l'ultima commit di lavoro usando git log quindi esegui
quando il ramo remoto funziona di nuovo, puoi
questo metodo è migliore di git checkout per le modifiche temporanee, perché non sei in uno stato distaccato.
il modo meno complicato per ripristinare un branch a una commit particolare dove non puoi cambiare la cronologia che ho trovato è:
come ad esempio:
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.
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:
questo tornerà sul repository locale, qui dopo aver usato
git push -faggiornerà il repository remoto.niente qui ha funzionato per me a parte questa combinazione esatta:
chiave qui sta forzando il push, nessun messaggio extra commit / commit etc.
su GitKraken puoi fare questo:
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.
ripristinare la commit più recente:
HEADè semplicemente un riferimento alla commit corrente (ultima) sul ramo corrente. ci può essere solo un singoloHEADin un dato momento.ripristinare una vecchia commit: il modo più veloce per ripristinare una vecchia versione è usare il comando
reset: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:
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.
reimpostazione Modifiche e commit
il comando
git resetti 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 chiamandogit 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. eseguiregit reset -hardHEAD fa la stessa cosa di git checkout HEAD. solo che non richiede un file o un percorso di lavoro. puoi usare--softcon 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--mixedper 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 revertfa 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-nper 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.non ho visto usare cherry-pick:
cherry-pick A: