Расширение того, что я написал в комментарии

Общее правило состоит в том, что вы не должны переписывать (изменять) историю, которую вы опубликовали, потому что кто-то мог основывать свою работу на ней. Если вы переписываете (изменяете) историю, у вас могут возникнуть проблемы с объединением их изменений и с их обновлением.

Итак, решение состоит в том, чтобы создать новую фиксацию, которая отменяет изменения, от которых вы хотите избавиться. Вы можете сделать это с помощью git revert".

У вас следующая ситуация:

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

(здесь стрелки указывают направление указателя: родительская ссылка в случае фиксации, верхняя фиксация в случае заголовка ветки (ссылка ветки) и имя ветки в случае ссылки HEAD).

Вам нужно создать следующее:

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

где [(BCD)^-1] означает фиксацию, которая отменяет изменения в коммитах B, C, D. Математика говорит нам, что (BCD) ^-1 = D ^-1 C ^{-1 < / sup> B -1, поэтому вы можете получить требуемую ситуацию, используя следующие команды:}

$ git revert --no-commit D
$ git revert --no-commit C
$ git revert --no-commit B
$ git commit -m "the commit message for all of them"

Работает для всего, кроме коммитов слияния.

Альтернативным решением было бы проверить содержимое фиксации A и зафиксировать это состояние. Также работает с коммитами слияния. Однако добавленные файлы не будут удалены. Если у вас есть какие-либо локальные изменения git stash сначала:

$ git checkout -f A -- . # checkout that revision over the top of local files
$ git commit -a

Тогда у вас будет следующая ситуация:

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

Фиксация A 'имеет то же содержимое, что и фиксация A, но представляет собой другую фиксацию (сообщение фиксации, родители, дата фиксации).

Альтернативное решение Джеффа Ферланда, измененное Чарльзом Бейли, основано на той же идее, но использует git reset. Здесь он немного видоизменен, так РАБОТАЕТ НА ВСЕ:

$ git reset --hard A
$ git reset --soft D # (or ORIG_HEAD or @{1} [previous location of HEAD]), all of which are D
$ git commit

Чистый способ, который я нашел полезным

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

Эта команда отменяет последние 3 фиксации только с одной фиксацией.

И не переписывает историю.

.. помогает создать диапазон. Значение HEAD~3.. совпадает с HEAD~3..HEAD

Для этого вам просто нужно использовать команду revert, указав диапазон коммитов, которые вы хотите отменить.

Принимая во внимание ваш пример, вам нужно будет сделать это (при условии, что вы находитесь в ветке master):

git revert master~3..master

or git revert B...D or git revert D C B

Это создаст новую фиксацию на вашем локальном компьютере с обратной фиксацией B, C и D (что означает, что она отменит изменения, внесенные этими фиксациями):

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

Подобно ответу Якуба, это позволяет вам легко выбирать последовательные коммиты для возврата.

# 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

Это будет действовать как возврат для всех сразу. Дайте хорошее сообщение о фиксации.

Сначала убедитесь, что ваша рабочая копия не изменена. Потом:

git diff --binary HEAD commit_sha_you_want_to_revert_to | git apply

а затем просто зафиксируйте. Не забудьте указать причину возврата.

Я так расстроен, что на этот вопрос нельзя просто ответить. Все остальные вопросы касаются того, как правильно повернуть вспять и сохранить историю. В этом вопросе говорится: "Я хочу, чтобы голова ветки указывала на A, т.е. я хочу, чтобы B, C, D и HEAD исчезли, и я хочу, чтобы голова была синонимом A."

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

Я многому научился, читая пост Якуба, но какой-то парень в компании (с доступом к нашей «тестовой» ветке без Pull-Request) выдвинул как 5 плохих коммитов, пытаясь исправить и исправить ошибку, которую он сделал 5 коммитов назад. Не только это, но и один или два запроса на извлечение были приняты, что теперь было плохо. Так что забудьте, я нашел последнюю удачную фиксацию (abc1234) и просто запустил базовый скрипт:

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

Я сказал другим 5 парням, работающим в этом репо, что им лучше записать свои изменения за последние несколько часов и стереть / повторно ветвиться из последнего тестирования. Конец истории.

Это расширение одного из решений, представленных в ответе Якуба

Я столкнулся с ситуацией, когда коммиты, которые мне нужно было откатить, были довольно сложными, некоторые из которых были коммитами слияния, и мне нужно было избегать перезаписи истории. Мне не удалось использовать серию git revert команд, потому что в конечном итоге я столкнулся с конфликтами между добавляемыми изменениями реверсии. В итоге я использовал следующие шаги.

Сначала проверьте содержимое целевого коммита, оставив HEAD на конце ветки:

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

(- гарантирует, что <target-commit> интерпретируется как фиксация, а не как файл;. Относится к текущему каталогу.)

Затем определите, какие файлы были добавлены в откат коммитов и, следовательно, должны быть удалены:

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

Добавленные файлы должны отображаться с буквой «A» в начале строки, и других различий быть не должно. Теперь, если необходимо удалить какие-либо файлы, подготовьте эти файлы для удаления:

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

Наконец, зафиксируйте возврат:

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

При желании убедитесь, что мы вернулись в желаемое состояние:

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

Никаких отличий быть не должно.

Самый простой способ отменить группу коммитов в общем репозитории (который люди используют и вы хотите сохранить историю) - использовать git revert в сочетании с git rev-list. Последний предоставит вам список коммитов, первый сделает откат самостоятельно.

Это можно сделать двумя способами. Если вы хотите вернуть несколько коммитов за один коммит, используйте:

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

это вернет группу необходимых вам коммитов, но оставит все изменения в вашем рабочем дереве, после чего вы должны зафиксировать их все как обычно.

Другой вариант - иметь одну фиксацию для каждого отмененного изменения:

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

Например, если у вас есть дерево фиксации вроде

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

чтобы отменить изменения с eee на bbb, запустите

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

Ни один из них не сработал для меня, поэтому у меня было три коммита, которые нужно было отменить (последние три коммита), поэтому я сделал:

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

Сработало как шарм :)

На мой взгляд, очень простой и понятный способ:

вернуться к А

git checkout -f A

навести голову мастера на текущее состояние

git symbolic-ref HEAD refs/heads/master

спасти

git commit

Вероятно, менее элегантно, чем другие подходы здесь, но я всегда использовал get reset --hard HEAD~N для отмены нескольких коммитов, где N - количество коммитов, которые вы хотите вернуть.

Или, если вы не уверены в точном количестве коммитов, просто запустите git reset --hard HEAD^ (который возвращает одну фиксацию) несколько раз, пока не достигнете желаемого состояния.

Очень хотелось избежать жестких сбросов, вот что я придумал.

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

Чтобы вернуться к A (что на 4 шага назад):

git pull                  # Get latest changes
git reset --soft HEAD~4   # Set back 4 steps
git stash                 # Stash the reset
git pull                  # Go back to head
git stash pop             # Pop the reset 
git commit -m "Revert"    # Commit the changes

если ты

1. есть объединенная фиксация и
2. вы не можете вернуться, и
3. Вы не против раздавить историю, которую хотите вернуть,

тогда ты можешь

git reset --soft HEAD~(number of commits you'd like to revert)
git commit -m "The stuff you didn't like."
git log
# copy the hash of your last commit
git revert <hash of your last (squashed) commit>

Затем, когда вы хотите отправить свои изменения, не забудьте использовать флаг -f, потому что вы изменили историю

git push <your fork> <your branch> -f

Если вы хотите временно отменить коммиты функции, вы можете использовать серию следующих команд.

Вот как это работает

git log --pretty = oneline | grep 'feature_name' | вырезать -d '' -f1 | xargs -n1 git revert --no-edit