Eu tenho um repositório git que se parece com isso:

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

Quero que o chefe do ramo aponte para A, ou seja, quero que B, C, D e HEAD desapareçam e quero que o cabeçote seja sinônimo de A.

Parece que eu posso tentar fazer uma nova reformulação (não se aplica, desde que eu coloquei alterações no meio) ou reverter. Mas como reverto várias confirmações? Eu reverto um de cada vez? A ordem é importante?

Expandindo o que escrevi em um comentário

A regra geral é que você não deve reescrever (alterar) o histórico que você publicou, porque alguém pode ter baseado seu trabalho nele. Se você reescrever (alterar) o histórico, terá problemas ao mesclar as alterações e atualizar para elas.

Portanto, a solução é criar um novo commit que reverta as alterações das quais você deseja se livrar. Você pode fazer isso usando o comando git revert .

Você tem a seguinte situação:

A <- B <- C <- D <- mestre <- CABEÇA

(as setas aqui se referem à direção do ponteiro: a referência "pai" no caso de confirmações, a confirmação superior no caso de cabeçalho de ramificação (ref de ramificação) e o nome da ramificação no caso de referência HEAD).

O que você precisa criar é o seguinte:

A <- B <- C <- D <- [(BCD) ^ - 1] <- mestre <- CABEÇA

onde "[(BCD) ^ - 1]" significa o commit que reverte as alterações nos commits B, C, D. A matemática nos diz que (BCD) ^ - 1 = D ^ -1 C ^ -1 B ^ -1, então você pode obter a situação necessária usando os seguintes comandos:

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

A solução alternativa seria verificar o conteúdo da confirmação A e confirmar este estado:

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

Então você teria a seguinte situação:

A <- B <- C <- D <- A '<- mestre <- CABEÇA

A confirmação A 'tem o mesmo conteúdo que a confirmação A, mas é uma confirmação diferente (mensagem de confirmação, pais, data de confirmação).

A solução de Jeff Ferland, modificada por Charles Bailey, baseia-se na mesma idéia, mas usa git reset :

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

Maneira limpa que eu achei útil

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

Este comando reverte os últimos 3 commit com apenas um commit.

Também não reescreve o histórico.

Para fazer isso, basta usar o comando revert , especificando o intervalo de confirmações que você deseja que seja revertido.

Levando em conta o seu exemplo, você teria que fazer isso (supondo que você esteja no ramo 'master'):

git revert master~3..master

Isso criará um novo commit no seu local com o commit inverso de B, C e D (o que significa que ele desfará as alterações introduzidas por esses commit):

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

Semelhante à resposta de Jakub, isso permite que você selecione facilmente confirmações consecutivas para reverter.

# 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

Isso funcionará como uma reversão para todos eles de uma vez. Dê uma boa mensagem de confirmação.

Primeiro, verifique se a sua cópia de trabalho não está modificada. Então:

git diff HEAD commit_sha_you_want_to_revert_to | git apply

e depois apenas confirmar. Não se esqueça de documentar qual é o motivo da reversão.

Estou tão frustrado que esta pergunta não pode ser respondida. Todas as outras questões estão relacionadas a como reverter corretamente e preservar a história. Esta pergunta diz "Eu quero que o chefe do ramo aponte para A, ou seja, quero que B, C, D e HEAD desapareçam e quero que o cabeçote seja sinônimo de A."

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

Eu aprendi muito lendo o post de Jakub, mas um cara da empresa (com acesso para enviar para o nosso ramo de "testes" sem solicitação de solicitação) fez 5 commits ruins, tentando consertar e consertar um erro que ele cometeu há 5 commits atrás. Não apenas isso, mas uma ou duas solicitações pull foram aceitas, que agora eram ruins. Então esqueça, eu encontrei o último bom commit (abc1234) e executei o script básico:

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

Eu disse aos outros 5 funcionários que trabalhavam neste repositório que é melhor anotarem suas alterações nas últimas horas e limpar / re-ramificar nos testes mais recentes. Fim da história.

Esta é uma expansão de uma das soluções fornecidas na resposta de Jakub

Fui confrontado com uma situação em que as confirmações necessárias para reverter eram um pouco complexas, com várias confirmações sendo confirmadas por mesclagem e eu precisava evitar reescrever o histórico. Não pude usar uma série de git revertcomandos porque acabei encontrando conflitos entre as alterações de reversão sendo adicionadas. Acabei seguindo os seguintes passos.

Primeiro, verifique o conteúdo da confirmação do destino, deixando HEAD na ponta do ramo:

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

(O - garante que <target-commit>seja interpretado como uma confirmação em vez de um arquivo; o. Refere-se ao diretório atual.)

Em seguida, determine quais arquivos foram adicionados nas confirmações sendo revertidas e, portanto, precisam ser excluídos:

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

Os arquivos adicionados devem aparecer com um "A" no início da linha e não deve haver outras diferenças. Agora, se algum arquivo precisar ser removido, prepare esses arquivos para remoção:

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

Por fim, confirme a reversão:

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

Se desejar, verifique se estamos de volta ao estado desejado:

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

Não deve haver diferenças.

A maneira mais fácil de reverter um grupo de confirmações no repositório compartilhado (que as pessoas usam e você deseja preservar o histórico) é usar git revertem conjunto com o git rev-list. O último fornecerá uma lista de confirmações, o primeiro fará a reversão em si.

Existem duas maneiras de fazer isso. Se você deseja reverter várias confirmações em uma única confirmação, use:

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

isso reverterá um grupo de confirmações necessárias, mas deixe todas as alterações na sua árvore de trabalho; você deve confirmar todas elas normalmente.

Outra opção é ter uma única confirmação por alteração revertida:

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

Por exemplo, se você tiver uma árvore de confirmação como

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

para reverter as alterações de eee para bbb , execute

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

Nenhum deles funcionou para mim, então eu tinha três confirmações para reverter (as últimas três confirmações), então fiz:

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

Trabalhou como um encanto :)

Na minha opinião, uma maneira muito fácil e limpa pode ser:

volte para A

git checkout -f A

aponte a cabeça do mestre para o estado atual

git symbolic-ref HEAD refs/heads/master

Salve 

git commit

Se você quiser reverter temporariamente as confirmações de um recurso, poderá usar a série de comandos a seguir.

Aqui está como funciona

git log --pretty = on-line | grep 'feature_name' | cut -d '' -f1 | xargs -n1 git revert --no-edit