Ho un repository git che assomiglia a questo:

A -> B -> C -> D -> HEAD

Voglio che la testa del ramo punti ad A, cioè voglio che B, C, D e HEAD scompaiano e voglio che la testa sia sinonimo di A.

Sembra che io possa provare a riformulare (non si applica, dal momento che ho inserito le modifiche) o ripristinare. Ma come posso ripristinare più commit? Devo ripristinarne uno alla volta? L'ordine è importante?

Espandendo quello che ho scritto in un commento

La regola generale è che non dovresti riscrivere (cambiare) la storia che hai pubblicato, perché qualcuno potrebbe aver basato il proprio lavoro su di esso. Se riscrivi (cambi) la cronologia, avresti problemi con l'unione delle loro modifiche e con l'aggiornamento per esse.

Quindi la soluzione è quella di creare un nuovo commit che ripristini le modifiche che si desidera eliminare. Puoi farlo usando il comando git revert .

Hai la seguente situazione:

A <- B <- C <- D <- master <- HEAD

(le frecce qui si riferiscono alla direzione del puntatore: il riferimento "parent" nel caso di commit, il commit superiore nel caso della testa del ramo (riferimento ramo) e il nome del ramo nel caso del riferimento HEAD).

Quello che devi creare è il seguente:

A <- B <- C <- D <- [(BCD) ^ - 1] <- master <- HEAD

dove "[(BCD) ^ - 1]" indica il commit che ripristina le modifiche nei commit B, C, D. La matematica ci dice che (BCD) ^ - 1 = D ^ -1 C ^ -1 B ^ -1, quindi puoi ottenere la situazione richiesta usando i seguenti comandi:

$ git revert --no-commit D
$ git revert --no-commit C
$ git revert --no-commit B
$ git commit -m "the commit message"

Una soluzione alternativa sarebbe quella di verificare il contenuto del commit A e commettere questo stato:

$ git checkout -f A -- .
$ git commit -a

Quindi avresti la seguente situazione:

A <- B <- C <- D <- A '<- master <- HEAD

Il commit A 'ha gli stessi contenuti del commit A, ma è un commit diverso (messaggio di commit, genitori, data di commit).

La soluzione di Jeff Ferland, modificata da Charles Bailey si basa sulla stessa idea, ma utilizza git reset :

$ git reset --hard A
$ git reset --soft @{1}  # (or ORIG_HEAD), which is D
$ git commit

Modo pulito che ho trovato utile

git revert --no-commit HEAD~3..

Questo comando ripristina gli ultimi 3 commit con un solo commit.

Inoltre non riscrive la storia.

Per fare ciò devi solo usare il comando revert , specificando l'intervallo di commit che vuoi ripristinare.

Tenendo conto del tuo esempio, dovresti farlo (supponendo che tu sia nel ramo 'master'):

git revert master~3..master

Ciò creerà un nuovo commit nel tuo locale con il commit inverso di B, C e D (il che significa che annullerà le modifiche introdotte da questi commit):

A <- B <- C <- D <- BCD' <- HEAD

Simile alla risposta di Jakub, ciò consente di selezionare facilmente commit consecutivi da ripristinare.

# revert all commits from B to HEAD, inclusively
$ git revert --no-commit B..HEAD  
$ git commit -m 'message'

git reset --hard a
git reset --mixed d
git commit

Questo fungerà da ritorno per tutti in una volta. Dai un buon messaggio di commit.

Innanzitutto assicurati che la tua copia di lavoro non sia stata modificata. Poi:

git diff HEAD commit_sha_you_want_to_revert_to | git apply

e poi basta impegnarsi. Non dimenticare di documentare qual è il motivo del ripristino.

Sono così frustrato che non è possibile rispondere a questa domanda. Ogni altra domanda riguarda come ripristinare correttamente e preservare la storia. Questa domanda dice "Voglio che il capo del ramo punti ad A, cioè voglio che B, C, D e HEAD scompaiano e voglio che la testa sia sinonimo di A."

git checkout <branch_name>
git reset --hard <commit Hash for A>
git push -f

Ho imparato molto leggendo il post di Jakub, ma un ragazzo della compagnia (con accesso per spingere al nostro ramo "testing" senza Pull-Request) ha spinto come 5 cattivi commit cercando di risolvere e correggere e correggere un errore che ha fatto 5 commit fa. Non solo, ma furono accettate una o due richieste pull, che ora erano cattive. Quindi dimenticalo, ho trovato l'ultimo buon commit (abc1234) e ho appena eseguito lo script di base:

git checkout testing
git reset --hard abc1234
git push -f

Ho detto agli altri 5 ragazzi che lavorano in questo repository che è meglio prendere nota dei loro cambiamenti nelle ultime ore e cancellare / ripetere i rami dagli ultimi test. Fine della storia.

Questa è un'espansione di una delle soluzioni fornite nella risposta di Jakub

Mi trovavo di fronte a una situazione in cui gli commit di cui avevo bisogno per eseguire il rollback erano in qualche modo complessi, con molti degli commit che erano merge di commit, e avevo bisogno di evitare di riscrivere la storia. Non sono stato in grado di utilizzare una serie di git revertcomandi perché alla fine mi sono imbattuto in conflitti tra le modifiche di inversione aggiunte. Ho finito con i seguenti passaggi.

Innanzitutto, controlla il contenuto del commit di destinazione lasciando HEAD sulla punta del ramo:

$ git checkout -f <target-commit> -- .

(Il - si assicura che <target-commit>sia interpretato come un commit piuttosto che un file; il. Si riferisce alla directory corrente.)

Quindi, determinare quali file sono stati aggiunti nei commit di cui è stato eseguito il rollback e quindi devono essere eliminati:

$ git diff --name-status --cached <target-commit>

I file aggiunti dovrebbero essere visualizzati con una "A" all'inizio della riga e non dovrebbero esserci altre differenze. Ora, se è necessario rimuovere eventuali file, posizionare questi file per la rimozione:

$ git rm <filespec>[ <filespec> ...]

Infine, commetti l'inversione:

$ git commit -m 'revert to <target-commit>'

Se lo si desidera, assicurarsi che siamo tornati allo stato desiderato:

$git diff <target-commit> <current-commit>

Non ci dovrebbero essere differenze.

Il modo semplice per ripristinare un gruppo di commit su un repository condiviso (che le persone usano e che vuoi conservare la cronologia) è usare git revertinsieme a git rev-list. Quest'ultimo ti fornirà un elenco di commit, il primo eseguirà il ripristino stesso.

Ci sono due modi per farlo. Se si desidera ripristinare più commit in un unico commit, utilizzare:

for i in `git rev-list <first-commit-sha>^..<last-commit-sha>`; do git revert -n $i; done

questo ripristinerà un gruppo di commit di cui hai bisogno, ma lascia tutte le modifiche sul tuo albero di lavoro, dovresti impegnarle tutte come al solito.

Un'altra opzione è avere un unico commit per ogni modifica ripristinata:

for i in `git rev-list <first-commit-sha>^..<last-commit-sha>`; do git revert --no-edit -s $i; done

Ad esempio, se hai un albero di commit come

 o---o---o---o---o---o--->    
fff eee ddd ccc bbb aaa

per ripristinare le modifiche da eee a bbb , eseguire

for i in `git rev-list eee^..bbb`; do git revert --no-edit -s $i; done

Nessuno di quelli ha funzionato per me, quindi ho avuto tre commit da ripristinare (gli ultimi tre commit), quindi ho fatto:

git revert HEAD
git revert HEAD~2
git revert HEAD~4
git rebase -i HEAD~3 # pick, squash, squash

Ha funzionato come un fascino :)

Secondo me un modo molto semplice e pulito potrebbe essere:

tornare ad A

git checkout -f A

punta la testa del padrone allo stato attuale

git symbolic-ref HEAD refs/heads/master

Salva

git commit

Se si desidera ripristinare temporaneamente i commit di una funzione, è possibile utilizzare la serie dei seguenti comandi.

Ecco come funziona

git log --pretty = oneline | grep 'feature_name' | cut -d '' -f1 | xargs -n1 git ripristina --no-edit