78 Вопрос: Как мне отменить последние локальные коммиты в Git?

вопрос создан в Wed, May 29, 2019 12:00 AM

Я случайно отправил неверные файлы в Git , но я не выдвинул коммит в сервер пока.

Как я могу отменить эти коммиты из локального репозитория?

    
19738
  1. Предупреждение: вы должны делать это только в том случае, если вы еще не передали коммит на удаленный компьютер, в противном случае вы можете испортить историю других, которые уже вынули коммит из пульт!
    2015-05-13 21: 18: 57Z
  2. Вот очень четкое и подробное сообщение об удалении вещей в git, прямо из Github.
    2015-06-08 19: 39: 17Z
  3. Прежде чем опубликовать новый ответ, учтите, что на этот вопрос уже есть более 65 ответов. Убедитесь, что ваш ответ способствует тому, чего нет среди существующих ответов.
    2017-06-15 15: 26: 36Z
  4. Вы знаете, что нужно git? git undo, вот и все. Затем репутация Git по обработке ошибок, совершенных нами, простыми смертными, исчезает. Реализуйте, поместив текущее состояние в стек git перед выполнением любой команды git. Это повлияет на производительность, поэтому было бы лучше добавить флаг конфигурации относительно того, включать ли его.
    2018-03-20 01: 45: 28Z
  5. @ YiminRong Это можно сделать с помощью функции Git alias: git-scm.com/book/en/v2/Git-Basics-Git-Aliases
    2018-10-05 14: 50: 08Z
30 ответов                              30                         

Отменить коммит и повторить

$ git commit -m "Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
<< edit files as necessary >>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)
  1. Это то, что вы хотите отменить.
  2. Это оставляет ваше рабочее дерево (состояние ваших файлов на диске) без изменений, но отменяет фиксацию и оставляет внесенные вами изменения неизмененными (поэтому они будут отображаться как «Изменения не подготовлены для фиксации» в git status, так что вы нужно добавить их еще раз перед совершением). Если вы только хотите добавить больше изменений в предыдущую фиксацию или изменить сообщение фиксации 1 , вы можете использовать вместо него git reset --soft HEAD~, что похоже на git reset HEAD~ (где HEAD~ совпадает с HEAD~1), но оставляет существующие изменения поэтапно.
  3. Внесите исправления в рабочие файлы дерева.
  4. git add все, что вы хотите включить в свой новый коммит.
  5. Зафиксируйте изменения, повторно используя старое сообщение. reset скопировал старую голову в .git/ORIG_HEAD; commit с -c ORIG_HEAD откроет редактор, который изначально содержит сообщение журнала из старого коммита и позволяет его редактировать. Если вам не нужно редактировать сообщение, вы можете использовать опцию -C.

Однако помните, что если вы добавили какие-либо новые изменения в индекс, то с помощью commit --amend они будут добавлены в ваш предыдущий коммит.

Если код уже передан на ваш сервер и у вас есть права на перезапись истории (перебазирование), тогда:

git push origin master --force

Вы также можете посмотреть на этот ответ:

Как переместить ГОЛОВУ назад в предыдущее место? (Отдельная голова) & Отменить фиксацию

Приведенный выше ответ покажет вам git reflog, который используется, чтобы узнать, что такое SHA-1, к которому вы хотите вернуться. Как только вы нашли точку, к которой вы хотите отменить, используйте последовательность команд, как описано выше.

1 Однако обратите внимание, что вам не нужно возвращаться к более ранней фиксации, если вы только что допустили ошибку в своем сообщении фиксации . ВостокМожно выбрать git reset (чтобы отменить внесение изменений, которые вы сделали с тех пор), а затем git commit --amend , что откроет ваш коммит по умолчанию редактор сообщений, предварительно заполненный последним сообщением о коммите.

    
21340
2019-05-20 20: 06: 45Z
  1. И если фиксация была в неправильной ветви, вы можете git checkout theRightBranch со всеми этапами изменений. Как я только что должен был сделать.
    2010-10-05 15: 44: 20Z
  2. Если вы работаете в DOS, вместо git reset --soft HEAD^ вам нужно использовать git reset --soft HEAD~1. Символ ^ в DOS является продолжением, поэтому он не будет работать должным образом. Кроме того, --soft является значением по умолчанию, поэтому вы можете его опустить, если хотите, и просто сказать git reset HEAD~1.
    2011-04-13 14: 15: 10Z
  3. Кроме того, в zsh вы должны заключить в кавычки ^, поэтому git reset --soft 'HEAD^' ... по крайней мере, я сделал
    2011-10-27 18: 24: 16Z
  4. (Исправление к тому, что я написал выше; значение по умолчанию: --mixed. --mixed означает сохранение измененных файлов, но не сохранение их в индексе. --soft будет сохранять измененные файлы и сохраните их в индексе, как они были непосредственно перед измененным коммитом. Извините за путаницу.)
    2011-11-17 02: 40: 53Z
  5. пользователи zsh могут получить: zsh: no matches found: HEAD^ - вам нужно экранировать ^, т.е. git reset --soft HEAD\^
    2013-02-21 17: 47: 56Z

Отмена коммита немного страшна, если вы не знаете, как он работает. Но на самом деле это удивительно легко, если вы понимаете.

Скажем, у вас это есть, где C - это ГОЛОВА, а (F) - это состояние ваших файлов.

   (F)
A-B-C
    ↑
  master

Вы хотите сделать ядерный коммит C и больше никогда его не видеть . Вы делаете это:

git reset --hard HEAD~1

Результат:

 (F)
A-B
  ↑
master

Теперь Б - ГОЛОВА. Поскольку вы использовали --hard, ваши файлы возвращаются в свое состояние при фиксации B.

Ах, но предположим, что commit C был не катастрофой, а всего лишь ошибкой. Вы хотите отменить фиксацию, но сохраните свои изменения , чтобы немного отредактировать их, прежде чем улучшать фиксацию. Начиная снова здесь, с C в качестве вашей головы:

   (F)
A-B-C
    ↑
  master

Вы можете сделать это, исключив --hard:

git reset HEAD~1

В этом случае результат будет следующим:

   (F)
A-B-C
  ↑
master

В обоих случаях HEAD - это просто указатель на последний коммит. Когда вы делаете git reset HEAD~1, вы говорите Git переместить указатель HEAD назад на один коммит. Но (если вы не используете --hard) вы оставляете свои файлы такими, какими они были. Итак, теперь git status показывает изменения, которые вы зарегистрировали в C. Вы ничего не потеряли!

Для самого легкого прикосновения вы можете даже отменить свой коммит, но оставить свои файлы и свой shas (который есть хэши), в которые вы переместились. Найдите коммит, который вы уничтожили, и сделайте следующее:

git checkout -b someNewBranchName shaYouDestroyed

Вы сейчас воскресили этот коммит. Комитеты на самом деле не уничтожаются в Git в течение примерно 90 дней, поэтому обычно вы можете вернуться и спасти того, от которого не хотели избавиться.

    
10293
2018-12-07 09: 56: 29Z
  1. @ dma_k, да. Или вы можете сделать git reset --hard HEAD^^ один раз. Я использую нотацию тильды (~), потому что нотация каретки (^) не работает в DOS.
    2012-02-25 15: 02: 44Z
  2. Еще один приятный совет: вы можете повторно присоединить ветвь к коммиту, из которого вы удалили его, с помощью git branch -f <branch> <commit-id>. Сохраняет необходимость повторного создания коммитов!
    2012-06-22 13: 11: 11Z
  3. Для новичка в git не очевидно, в чем разница между последними двумя опциями (--soft и тот, что над ним). Упоминание индекса не помогает, мы еще не знаем, что это значит. Связь @ nessur между soft и Ctrl-Z действительно помогла! Но я все еще не совсем понимаю разницу между этими двумя вариантами.
    2012-06-26 15: 56: 52Z
  4. Намного лучше сказать, почему что-то работает, чем просто сказать ответ. Престижность этому описанию - это помогло быть 'get' git.
    2012-07-03 19: 13: 35Z
  5. Отсутствует критический момент: если указанный коммит ранее был «передан» на удаленный компьютер, любая операция «отменить», какой бы простой она ни была, вызовет огромную боль и страдания остальным пользователям, которые имеют этот коммит в своей локальной копии, когда они сделают «git pull» в будущем. Итак, если фиксация уже была «нажата», сделайте это: git revert < bad-commit-sha1-id > git push origin:
    2013-11-08 23: 43: 18Z

Мне потребовалось некоторое время, чтобы понять, так что, возможно, это поможет кому-то ...

Существует два способа «отменить» ваш последний коммит, в зависимости от того, сделали ли вы коммит открытым или нет (передан в удаленный репозиторий):

Как отменить локальный коммит

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

git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

Чтобы восстановить все, как было до последнего коммита, нам нужно reset до коммита до HEAD:

git reset --soft HEAD^     # use --soft if you want to keep your changes
git reset --hard HEAD^     # use --hard if you don't care about keeping the changes you made

Теперь git log покажет, что наш последний коммит был удален.

Как отменить публичный коммит

Если вы уже сделали свои коммиты общедоступными, вы захотите создать новый коммит, который "отменит" изменения, сделанные вами в предыдущем коммите (текущем HEAD).

git revert HEAD

Теперь ваши изменения будут отменены и готовы к фиксации.

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Для получения дополнительной информации ознакомьтесь с Основами Git - Отмена вещей р>     

1966
2018-01-30 23: 27: 24Z
  1. Я нашел этот ответ наиболее ясным. git revert HEAD^ - это не предыдущий, а предыдущий предыдущий. Я сделал: git revert HEAD, а затем нажмите еще раз, и это сработало:)
    2011-07-14 08: 32: 53Z

Добавляйте /удаляйте файлы, чтобы все было так, как вы хотите:

git rm classdir
git add sourcedir

Затем измените коммит.

git commit --amend

Предыдущая ошибочная фиксация будет отредактирована с учетом нового состояния индекса - иными словами, вы, как и прежде, никогда не допустили ошибку.

Обратите внимание, что делать это следует только в том случае, если вы еще не нажали. Если вы нажали, то вам просто нужно зафиксировать исправление в обычном режиме.

    
1685
2016-10-12 06: 45: 55Z
  1. Это работает, когда я сделал git commit --amend и что я действительно имел в видусделать это git commit?
    2011-05-18 13: 07: 31Z
  2. @ dbm, если вы случайно внесли изменения, используйте git reset --soft <oldref>, где oldref - идентификатор фиксации перед изменением. Вы можете использовать git reflog для определения старого идентификатора фиксации. Это отменит действие поправки, но внесет изменения. Затем просто выполните git commit, чтобы зафиксировать как обычный коммит.
    2011-05-18 14: 20: 48Z
  3. @ Dennis, git commit --amend превращает текущее дерево (т.е. поэтапные изменения) в коммит, перезаписывая текущий HEAD. После этого они больше не считаются промежуточными, потому что они являются частью фиксации (т. Е. Git diff --cached пусто), но они не «удалены» и «не потеряны».
    2012-02-01 03: 08: 06Z
  4. Опция --amend была хитростью, чтобы избежать ложной фиксации!
    2019-03-22 19: 58: 29Z
git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

или р>

git reset --hard HEAD~1

Предупреждение. Приведенная выше команда навсегда удалит модификации файлов .java (и любых других файлов), которые вы хотели зафиксировать.

От hard reset до HEAD-1 ваша рабочая копия будет установлена ​​в состояние фиксации до вашей неверной фиксации.

    
954
2017-12-13 22: 03: 28Z
  1. "- hard" избавится от измененных файлов .java в рабочем каталоге, которые он хотел зафиксировать.
    2009-05-29 18: 26: 59Z
  2. Можно изменить изменения рабочей копии «git stash save», сделать полный сброс и затем «git stash pop», чтобы вернуть их обратно, хотя я полагаю, что мягкий сброс будет проще.
    2011-04-15 13: 33: 03Z
  3. git commit -a -m "" или git commit -am "" естественно! :]
    2014-06-21 16: 31: 59Z
  4. Еще одно «быстрое» использование stash; если вы хотите отменить все (отменить git add), просто git stash, а затем git stash pop
    2015-12-08 22: 30: 29Z

Чтобы изменить последний коммит

Заменить файлы в индексе:

git rm --cached *.class
git add *.java

Затем, если это частная ветка, измените коммит:

git commit --amend

Или, если это общая ветка, сделайте новый коммит:

git commit -m 'Replace .class files with .java files'


(, чтобы изменить предыдущий коммит , используйте потрясающую интерактивную перебазировку а>)

ProTip ™: добавьте *.class в gitignore , чтобы это больше не происходило. р>

Чтобы отменить коммит

Изменение коммита является идеальным решением, если вам нужно изменить последний коммит, но более общее решение - reset.

Вы можете сбросить git на любой коммит с помощью:

git reset @~N

Где N - количество коммитов до HEAD, а @~ сбрасывается до предыдущего коммита.

Таким образом, вместо внесения изменений в коммит, вы можете использовать:

git reset @~
git add *.java
git commit -m "Add .java files"

Проверьте git help reset, в частности разделы --soft --mixed и --hard, чтобы лучше понять, что это делает.

Reflog

Если вы запутались, вы всегда можете использовать reflog, чтобы найти упущенные коммиты:

$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started


    
724
2017-05-23 12: 03: 09Z
  1. Для тех, кто читает в будущем - обратите внимание, что git revert - это отдельная команда, которая в основном «сбрасывает» один коммит.
    2018-08-08 07: 11: 00Z

Используйте git revert <commit-id>

Чтобы получить идентификатор фиксации, просто используйте git log

    
612
2018-11-10 09: 36: 11Z
  1. Если вы зафиксировали неправильную ветвь: однажды вернувшись, переключитесь на правильную ветвь и выберите команду commit.
    2012-06-27 11: 02: 58Z
  2. Что это значит, вишня выберет коммит? В моем случае я находился не в той ветке, когда редактировал файл. Я совершил это, затем понял, что я был не в той ветке. Использование «git reset --soft HEAD ~ 1» вернуло меня непосредственно перед фиксацией, но теперь, если я извлекаю правильную ветвь, как мне отменить изменения в файле в неправильной ветке, но вместо этого внести их (с тем же именем файл) в правильной ветке?
    2015-01-13 22: 05: 57Z
  3. Я только что использовал git revert commit-id, работал как шарм. Конечно, тогда вам нужно будет нажать ваши изменения.
    2016-01-25 21: 07: 16Z
  4. Я полагаю, это будет git cherry-pick <<erroneous-commit-sha>> @astronomerdave. От, мистер почти 2 года, опоздал на вечеринку.
    2016-10-20 18: 19: 50Z
  5. @ Kris: вместо cherry-pick используйте rebase. Потому что это продвинутый сбор вишни
    2018-11-10 09: 38: 58Z

Если вы планируете полностью отменить локальный коммит, то, что вы изменили, вы сделали в коммите, и если вы не беспокоитесь об этом, просто выполните следующую команду.

git reset --hard HEAD^1

(Эта команда будет игнорировать весь ваш коммит, и ваши изменения будут полностью потеряны из вашего локального рабочего дерева). Если вы хотите отменить фиксацию, но хотите внести изменения в промежуточную область (перед фиксацией, как после git add), выполните следующую команду.

git reset --soft HEAD^1

Теперь ваши зафиксированные файлы попадают в промежуточную область. Предположим, что если вы хотите удалить файлы за кулисы, поскольку вам нужно отредактировать неправильный контент, выполните следующую команду

git reset HEAD

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

Подробнее р>     

494
2018-09-28 08: 43: 59Z
  1. @ SMR, в вашем примере все указывают только на текущий заголовок. ГОЛОВА ^ = ГОЛОВА ^ 1. А также HEAD ^ 1 = HEAD ~ 1. Когда вы используете HEAD ~ 2, между символами ~ и ^ есть разница. Если вы используете ~ 2, значит «первый родитель первого родителя» или «прародитель».
    2015-12-14 15: 34: 11Z

Если у вас установлено Git Extras , вы можете запустить git undo, чтобы отменить последнюю фиксацию. git undo 3 отменит последние 3 коммита.

    
466
2011-12-13 10: 18: 31Z

Я хотел отменить последние 5 коммитов в нашем общем хранилище. Я посмотрел идентификатор ревизии, на которую я хотел откатиться. Затем я набрал следующее.

prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt> git push origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To git@bitbucket.org:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>
    
433
2012-04-06 13: 58: 52Z
  1. Переписывание истории в общем хранилище, как правило, очень плохая идея. Я предполагаю, что вы знаете, что делаете, я просто надеюсь, что будущие читатели тоже.
    2012-12-07 16: 02: 12Z
  2. Да, откат опасен. Убедитесь, что ваша рабочая копия находится в желаемом состоянии, прежде чем нажать. При нажатии затем нежелательные коммиты удаляются навсегда.
    2012-12-08 14: 14: 43Z
  3. "Точно так же, как в реальном мире, если вы хотите переписать историю, вам нужен заговор: каждый должен быть замешан в заговоре (по крайней мере, каждый, кто знает об истории, т. е. всех, кто когда-либо вытягивал с ветки). " Источник: stackoverflow.com/a/2046748/334451
    2013-08-07 10: 10: 25Z

Я предпочитаю использовать git rebase -i для этой работы, потому что появляется хороший список, где я могу выбрать коммиты, от которых можно избавиться. Это может быть не так прямо, как некоторые другие ответы здесь, но просто кажется правильным .

Выберите, сколько коммитов вы хотите перечислить, а затем примените так (чтобы подключить последние три)

git rebase -i HEAD~3

Пример списка

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Затем Git удалит коммиты для любой удаляемой строки.

    
412
2018-12-06 21: 59: 20Z

Как исправить предыдущий локальный коммит

Используйте git-gui (или аналогичный) для выполнения git commit --amend. Из графического интерфейса вы можете добавлять или удалять отдельные файлы из фиксации. Вы также можете изменить сообщение коммита.

Как отменить предыдущий локальный коммит

Просто верните свою ветку в предыдущее местоположение (например, используя gitk или git rebase). Затем повторно примените изменения из сохраненной копии. После сборки мусора в вашем локальном хранилище будет похоже на то, что нежелательный коммит никогда не происходил. Чтобы сделать все это в одной команде, используйте git reset HEAD~1.

Слово предупреждения : Неосторожное использование git reset - хороший способ привести вашу рабочую копию в неясное состояние. Я рекомендую новичкам Git избегать этого, если они могут.

Как отменить публичный коммит

Выполните обратный выбор вишни ( git-revert ), чтобы отменить изменения.

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

git revert --no-edit HEAD

Затем отправьте обновленную ветку в общий репозиторий.

В истории коммитов будут показаны оба коммита по отдельности .

Дополнительно: исправление ветви private в общедоступном хранилище

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

Также обратите внимание: вы не хотите этого делать, если над веткой работает кто-то еще.

git push --delete (branch_name) ## remove public version of branch

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

git push origin (branch_name)

В нормальном случае вам, вероятно, не нужно беспокоиться о том, что ваша история коммитов в приватной ветке не искажается. Просто нажмите последующую фиксацию (см. Выше «Как отменить публичную фиксацию»), а затем выполните squash-merge скрыть историю.

    
398
2018-12-07 05: 57: 27Z
  1. gitk --all $(git reflog | cut -c1-7)& может быть полезен для поиска предыдущей ревизии, если вы хотите отменить'--amend' commit.
    2014-10-18 23: 38: 11Z
  2. Следует отметить, что если вы пытаетесь удалить секретную информацию, прежде чем отправлять ее в общий репозиторий, выполнение возврата не поможет вам, поскольку информация все равно будет быть в истории в предыдущем коммите. Если вы хотите убедиться, что изменения никогда не будут видны другим, вам нужно использовать git reset
    2015-09-04 04: 52: 01Z
  3. 2016-04-05 04: 20: 04Z
  4. Я думаю, что 'private' /'public' было бы более правильно, если бы он был 'local' /'remote'.
    2018-03-28 14: 59: 27Z
  5. Исправление приватной ветви в удаленном хранилище также можно выполнить просто git push origin (branch_name) --force
    2018-09-07 12: 09: 38Z

Если вы совершили мусор, но не были отправлены,

git reset --soft HEAD~1
  

HEAD ~ 1 - это сокращение для коммита перед головой. В качестве альтернативы вы можете обратиться к SHA-1 хэша, если хотите выполнить сброс. Опция - soft удалит фиксацию, но оставит все ваши измененные файлы «Изменениями, которые будут зафиксированы», как будет указано в git status.

     

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

ИЛИ р>

  

Если вы уже нажали, а кто-то нажал, что обычно является моим случаем, вы не можете использовать git reset . Однако вы можете выполнить git revert ,

git revert HEAD
  

Это создаст новый коммит, который перевернет все, что было введено случайным коммитом.

    
319
2014-09-25 07: 58: 25Z
  1. Я нахожусь во 2-м случае, но когда я делаю "git revert HEAD", он говорит "ошибка: Commit [ID] - это слияние, но опция -m не была дано. фатально: возврат не удался ". Есть предложения?
    2014-11-12 19: 36: 02Z
  2. Вероятно, стоит упомянуть, что вместо HEAD~1 можно использовать фактический хэш, отображаемый с помощью git log --stat или с помощью git reflog, - полезно, когда вам нужно «отменить» более одного коммита.
    2014-12-07 00: 38: 49Z

    Если вы хотите навсегда отменить это, и вы клонировали какой-то репозиторий

    Идентификатор коммита может видеть

    git log 
    

    Тогда вы можете сделать -

    git reset --hard <commit_id>
    
    git push origin <branch_name> -f
    
        
    316
    2015-06-24 09: 34: 15Z
    1. Что делать, если вы не используете "< commit_id >" и просто использовать "git reset --hard"? Как правило, я просто хочу избавиться от своих последних обновлений, которые я еще не зафиксировал, и вернулся к последнему принятому мною обновлению, и я всегда использую «git reset --hard».
      2017-09-27 23: 30: 18Z
    2. @ JaimeMontoya Чтобы отменить последние изменения, вы можете использовать git reset --hard, но если вам нужно жестко удалить последние коммиты "n", вы указываете SHA
      2017-09-28 13: 10: 31Z

    На SourceTree (графический интерфейс для GitHub) вы можетещелкните на коммите и выполните «Обратный коммит». Это должно отменить ваши изменения.

    На терминале:

    Вы также можете использовать:

    git revert
    

    Или:

    git reset --soft HEAD^ # Use --soft if you want to keep your changes.
    git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.
    
        
    269
    2015-06-24 09: 34: 11Z

    Одна команда:

    git reset --soft 'HEAD^' 
    

    Отлично работает отмена последнего локального коммита!

        
    250
    2014-07-21 20: 13: 34Z
    1. Мне нужно было написать git reset --soft "HEAD ^" с двойными кавычками, потому что я пишу это из командной строки Windows.
      2014-04-23 09: 13: 35Z
    2. Он должен работать без кавычек.
      2016-11-10 19: 19: 44Z

    Просто сбросьте его, выполнив приведенную ниже команду, используя git:

    git reset --soft HEAD~1
    

    Объясните , что делает git reset, это в основном reset для любого коммита, к которому вы хотите вернуться, тогда, если вы объедините его с ключом --soft, он вернется, но сохранит изменения в файл (ы), поэтому вы возвращаетесь к этапу, на котором файл был только что добавлен, HEAD - это заголовок ветви, и если вы объедините с ~1 (в этом случае вы также используете HEAD^), он вернется только к одному коммиту что то, что вы хотите ...

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

     Как отменить последние коммиты в Git?

        
    241
    2017-10-27 12: 46: 34Z

    Как отменить последний коммит Git?

    Чтобы восстановить все, как было до последнего коммита, нам нужно сбросить коммит до HEAD.

    1. Если вы не хотите сохранять внесенные изменения:

      git reset --hard HEAD^
      
    2. Если вы хотите сохранить изменения:

      git reset --soft HEAD^
      

    Теперь проверьте ваш журнал git. Это покажет, что наш последний коммит был удален.

        
    223
    2017-03-25 08: 14: 01Z

    Используйте reflog, чтобы найти правильное состояние

    git reflog
    

    reflog before ОБЗОР ПЕРЕД СБРОСОМ

    Выберите правильный reflog (в моем случае f3cb6e2) и введите

    git reset --hard f3cb6e2
    

    После этого заголовок репо будет сброшен на этот заголовок эффект сброса LOG AFTER RESET

    Наконец, рефлог выглядит как на картинке ниже

    reflog after ЗАКЛЮЧИТЕЛЬНЫЙ ФИНАЛ

        
    180
    2014-01-06 22: 34: 06Z

    «Сбросить рабочее дерево до последнего коммита»

    git reset --hard HEAD^ 
    

    «Удалить неизвестные файлы из рабочего дерева»

    git clean    
    

    см. - Краткое руководство по Git

    ПРИМЕЧАНИЕ. Эта команда удалит ваш предыдущий коммит, поэтому используйте его с осторожностью! git reset --hard безопаснее -

        
    173
    2017-12-13 22: 04: 48Z

    Первый запуск:

    git reflog
    

    Он покажет вам все возможные действия, которые вы выполнили в своем хранилище, например, фиксация, слияние, извлечение и т. д.

    Тогда делай:

    git reset --hard ActionIdFromRefLog
    
        
    156
    2015-06-24 09: 33: 20Z

    Отменить последний коммит:

    git reset --soft HEAD^ или git reset --soft HEAD~

    Это отменит последний коммит.

    Здесь --soft означает сброс в стадию.

    HEAD~ или HEAD^ означает переход к фиксации до HEAD.

    Заменить последний коммит на новый коммит:

    git commit --amend -m "message"
    

    Он заменит последний коммит новым коммитом.

        
    148
    2017-12-13 22: 05: 20Z

    Другой способ:

    Извлеките ветку, которую вы хотите вернуть, а затем сбросьте локальную рабочую копию на коммит, который вы хотите, чтобы он был последним на удаленном сервере (все после того, как оно пройдет до свидания). Для этого в SourceTree я щелкнул правой кнопкой мыши и выбрал «Сбросить BRANCHNAME для этого коммита».

    Затем перейдите в локальный каталог вашего репозитория и выполните эту команду:

    git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME
    

    Это удалит все коммиты после текущего в вашем локальном репозитории, но только для этой одной ветви.

        
    143
    2015-06-24 09: 34: 21Z

    Введите git log и найдите хэш-код последней фиксации, а затем введите:

    git reset <the previous co>
    
        
    134
    2015-06-24 09: 34: 18Z

    В моем случае я случайно зафиксировал некоторые файлы, которые мне не нужны. Поэтому я сделал следующее, и это сработало:

    git reset --soft HEAD^
    git rm --cached [files you do not need]
    git add [files you need]
    git commit -c ORIG_HEAD
    

    Проверьте результаты с помощью gitk или git log --stat

        
    130
    2015-06-24 09: 34: 09Z

    Просто запустите это в командной строке:

    git reset --soft HEAD~ 
    
        
    121
    2016-01-18 21: 58: 33Z

    Есть много способов сделать это:

    Команда Git для отмены последнего коммита /предыдущих коммитов:

    Предупреждение. Не используйте --hard, если вы не знаете, что делаете. --hard слишком опасен и может удалить ваши файлы.

    Основная команда для отмены фиксации в Git:

    $ git reset --hard <COMMIT -ID>
    

    или р>

    $ git reset --hard HEAD~<n>
    

    COMMIT-ID : идентификатор для фиксации

    n: - количество последних коммитов, которые вы хотите вернуть

    Вы можете получить идентификатор фиксации, как показано ниже:

    $ **git log --oneline**
    
    d81d3f1 function to subtract two numbers
    
    be20eb8 function to add two numbers
    
    bedgfgg function to mulitply two numbers
    

    где d81d3f1 и be20eb8 являются идентификатором фиксации.

    Теперь давайте рассмотрим несколько случаев:

    Предположим, вы хотите отменить последний коммит 'd81d3f1'. Вот два варианта:

    $ git reset --hard d81d3f1
    

    или р>

    $ git reset --hard HEAD~1
    

    Предположим, вы хотите отменить коммит 'be20eb8':

    $ git reset --hard be20eb8
    

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

    $ git reset --help
    
        
    119
    2018-08-19 14: 00: 16Z
    1. git reset --hard HEAD~1 слишком слишком опасно ! Это не только «отменит последний коммит», но и полностью вернет репо к предыдущему коммиту. Таким образом, вы потеряете все изменения, зафиксированные в последнем коммите!
      2017-03-21 12: 09: 47Z
    2. Вы правы, чтобы отменить это, вы можете использовать git push -f <remote> HEAD@{1}:<branch>
      2017-04-24 13: 07: 03Z
    3. К сожалению, я использую --hard, и мои файлы удалены! Сначала я не проверял комментарий, потому что он свернут. Не используйте --hard, если вы не знаете, что делаете!
      2018-08-19 13: 53: 17Z

    Для локальной фиксации

    git reset --soft HEAD~1
    

    или если вы точно не помните, в каком именно коммите это происходит, вы можете использовать

    git rm --cached <file>
    

    Для принудительной фиксации

    Правильный способ удаления файлов из истории репозитория - git filter-branch. То есть

    git filter-branch --index-filter 'git rm --cached <file>' HEAD
    

    Но я рекомендую вам использовать эту команду с осторожностью. Узнайте больше на странице руководства git-filter-branch (1) .

        
    117
    2014-07-21 20: 15: 08Z

    Есть два основных сценария

    Вы еще не добавили коммит

    Если проблема заключалась в добавленных вами дополнительных файлах (и они не нужны в хранилище), вы можете удалить их с помощью git rm, а затем зафиксировать с помощью --amend

    git rm <pathToFile>
    

    Вы также можете удалить целые каталоги с помощью -r или даже объединить их с другими командами Bash

    git rm -r <pathToDirectory>
    git rm $(find -name '*.class')
    

    После удаления файлов вы можете выполнить фиксацию с помощью опции - изменить

    .
    git commit --amend -C HEAD # the -C option is to use the same commit message
    

    Это перезапишет вашу недавнюю локальную фиксацию, удалив лишние файлы, поэтому эти файлы никогда не будут отправлены по запросу, а также будут удалены из вашего локального репозитория .git с помощью GC.

    Вы уже нажали на коммит

    Вы можете применить то же решение другого сценария, а затем выполнить git push с параметром -f, но это не рекомендуется , поскольку оно перезаписывает удаленную историю с расходящимися изменениями (это может испортить ваш репозиторий). ). р>

    Вместо этого вы должны выполнить коммит без --amend (помните об этом -amend`: эта опция переписывает историю последнего коммита).

        
    117
    2016-01-11 23: 50: 47Z

    Чтобы вернуться к предыдущей ревизии, окончательно удалите все незафиксированные изменения:

    git reset --hard HEAD~1
    
        
    117
    2016-09-16 07: 25: 01Z
    1. Возможно, вы можете заметить /предупредить, что его команда отбросит коммит и изменения в рабочем каталоге , не спрашивая больше.
      2014-11-24 22: 35: 29Z
    2. Если вы случайно сделали это, не все потеряно. Смотрите stackoverflow.com/questions/10099258/… , stackoverflow.com/questions/15479501/… и stackoverflow.com/questions/7374069/undo-git-reset-hard/7376959 .
      2014-11-24 22: 40: 57Z
    3. Используйте --soft, чтобы сохранить изменения как uncommitted changes, --hard, чтобы полностью обнулить коммит и вернуть его обратно на единицу. Не забывайте делать такие операции только с изменениями, которые еще не переданы.
      2015-03-09 09: 11: 06Z
    4. @ Zaz: Вы правы; возможно я должен был уточнить это. Только файлы /изменения, которые были либо добавлены в индекс (/staged), либо были зафиксированы, могут быть восстановлены. Неподтвержденные, неустановленные изменения , как вы сказали, полностью отброшены к git reset --hard.
      2016-09-13 21: 17: 10Z
    5. Как примечание: каждый раз, когда файл размещается, git сохраняет его содержимое в своей объектной базе данных. Сохраненное содержимое удаляется только при выполнении сборки мусора. Поэтому возможно восстановить последнюю поэтапную версию файла, которая в данный момент не была подготовлена ​​при выполнении git reset --hard (дополнительную информацию см. В сообщениях, ссылки на которые приведены выше).
      2016-09-13 21: 22: 52Z
источник размещен Вот
Другие вопросы