Разное

Отмена коммита git: Отмена коммитов — Введение в Git

Содержание

Отмена коммитов — Введение в Git

Введение в Git

Гит — система, в которой не нужно бояться совершать ошибки. Можно сказать, что это единственный способ научиться им пользоваться. В git практически всегда есть способ восстановить или изменить любые коммиты. На крайний случай спасет повторный git clone.

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

  • Забыли добавить в коммит нужные файлы
  • Изменения нужно «откатить», чтобы доработать
  • Изменения больше не актуальны, и их нужно удалить
  • Изменения были сделаны по ошибке, и их нужно отменить

Git по большей части система «только вперёд». Правильный подход при работе с гитом — создание нового, а не изменение старого. Все ситуации, описанные выше, можно решить новым коммитом, изменяющим код в нужном направлении. Это не только удобно, но и безопасно. Изменение истории коммитов — операция опасная и чревата проблемами при синхронизации с удалёнными репозиториями. Об этом мы поговорим позже.

Несмотря на сказанное выше, внутри git существуют специальные команды, позволяющие упростить отмену, либо изменение коммита. С их помощью можно сделать историю коммитов понятной, а сам процесс «отката» быстрым.

Git revert

Самая простая ситуация — отмена изменений. Фактически она сводится к созданию ещё одного коммита, который выполняет изменения противоположные тому коммиту, который отменяется. Руками создавать подобный коммит довольно сложно, поэтому в git добавили команду, автоматизирующую откат. Эта команда называется git revert:

# Этой команде нужен идентификатор коммита
# Это коммит, которым мы удалили файл PEOPLE.md
hexlet-git$: git revert aa600a43cb164408e4ad87d216bc679d097f1a6c
# После этой команды откроется редактор, ожидающий ввода описания коммита
# Обычно сообщение revert не меняют, поэтому достаточно просто закрыть редактор
[main 65a8ef7] Revert "remove PEOPLE. md"
 1 file changed, 1 insertion(+)
 create mode 100644 PEOPLE.md
# В проект вернулся файл PEOPLE.md

hexlet-git$ git log -p

commit 65a8ef7fd56c7356dcee35c2d05b4400f4467ca8
Author: tirion <[email protected]>
Date:   Sat Sep 26 15:32:46 2020 -0400

    Revert "remove PEOPLE.md"

    This reverts commit aa600a43cb164408e4ad87d216bc679d097f1a6c.

diff --git a/PEOPLE.md b/PEOPLE.md
new file mode 100644
index 0000000..4b34ba8
--- /dev/null
+++ b/PEOPLE.md
@@ -0,0 +1 @@
+Haskell Curry

Команда revert «отменяет» не только последний коммит, но и любой другой коммит из истории проекта. Согласитесь, это очень круто. Без системы контроля версий о таком нельзя было и мечтать.

Git reset

Иногда удалить нужно только что сделанный по ошибке коммит. Конечно, и в этом случае подходит git revert, но так загрязняется история. Если этот коммит сделан был только сейчас и ещё не отправлялся на Github, то лучше сделать так, как будто бы этого коммита не существовало в принципе.

Git позволяет удалять коммиты. Это опасная операция, которую нужно делать только в том случае, если речь идет про новые коммиты, которых нет ни у кого, кроме вас.

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

Для удаления коммита используется команда git reset. Делается это так:

# добавляем новый коммит, который мы сразу же удалим
hexlet-git$ echo 'test' >> INFO.md
hexlet-git$ git add INFO.md
hexlet-git$ git commit -m 'update INFO.md'
[main 17a77cb] update INFO.md
 1 file changed, 1 insertion(+)
 # Важно, что мы не делаем git push

 hexlet-git$ git reset --hard HEAD~
 HEAD is now at 65a8ef7 Revert "remove PEOPLE.md"

# Если посмотреть git log, то последнего коммита там больше нет

git reset — мощная команда, имеющая множество различных флагов и способов работы. С её помощью удаляются или отменяются (без удаления) коммиты, восстанавливаются файлы из истории и так далее. Работа с ней относится к продвинутому использованию git, здесь же мы затрагиваем только самую базу.

Флаг --hard означает полное удаление. Без него git reset отменит коммит, но не удалит его, а поместит все изменения этого коммита в рабочую директорию, так что с ними можно будет продолжить работать. HEAD~ означает «один коммит от последнего коммита». Если бы мы хотели удалить два последних коммита, то могли бы написать HEAD~2.

HEAD (голова) — так обозначается последний сделанный коммит. Подробнее эту терминологию мы разберем в уроке, посвященном внутреннему устройству git.

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

hexlet-git$ echo 'no code no pain' > README.md
hexlet-git$ git add README.md
hexlet-git$ git commit -m 'update README.md'
[main f85e3a6] update README.md
 1 file changed, 1 insertion(+)

# Теперь откатываем последний коммит
hexlet-git$ git reset HEAD~
Unstaged changes after reset:
M   README.md

hexlet-git$ git status
On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
    modified:   README.md

Последнего коммита больше не существует, но изменения, сделанные в нём, не пропали. Они находятся в рабочей директории для дальнейшей доработки.

Самостоятельная работа

  1. Выполните все шаги из урока
  2. Измените добавленный текст на No code No pain и закоммитьте его с сообщением «update README.md»
  3. Залейте изменения на Github

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты.

Ошибки, сложный материал, вопросы >

Нашли опечатку или неточность?

Выделите текст, нажмите
ctrl + enter
и отправьте его нам. В течение нескольких дней мы исправим ошибку или улучшим формулировку.

Что-то не получается или материал кажется сложным?

Загляните в раздел «Обсуждение»:

  • задайте вопрос. Вы быстрее справитесь с трудностями и прокачаете навык постановки правильных вопросов, что пригодится и в учёбе, и в работе программистом;
  • расскажите о своих впечатлениях. Если курс слишком сложный, подробный отзыв поможет нам сделать его лучше;
  • изучите вопросы других учеников и ответы на них. Это база знаний, которой можно и нужно пользоваться.
Об обучении на Хекслете

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

Я случайно зафиксировал неправильные файлы в Git , но еще не отправил их на сервер.

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

git

version-control

git-commit

undo

Поделиться

Источник


Hamza Yerlikaya    

29 мая 2009 в 18:09

25 ответов


  • git push, не нажимайте все локальные коммиты

    Я новичок в git и сейчас тестирую его. На моей локальной машине я часто совершаю коммиты. Через определенные промежутки времени я хочу протолкнуть код в центральное РЕПО. В данный момент я публикую все сделанные коммиты. Когда я работаю один, это не большая проблема, но когда я работаю с…

  • Git —bare … почему fetch не всегда показывает самые последние коммиты?

    У меня есть несколько репо GIT, которые я зеркально отразил локально, чтобы показать в своем экземпляре JIRA, но я заметил некоторое (для меня) странное поведение. У меня есть РЕПО, мы назовем это myrepo. Если я делаю git clone и git pull, я всегда получаю самые последние коммиты. Однако, когда я…



23327

Отменить фиксацию(коммит) и повторить

$ 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. Это ничего не делает с вашим рабочим деревом (состоянием ваших файлов на диске), но отменяет фиксацию(коммит) и оставляет изменения , которые вы зафиксировали, нестагированными (поэтому они будут отображаться как «Changes, а не поэтапно для commit» в git status, поэтому вам нужно будет добавить их снова перед фиксацией(коммитом)). Если вы хотите только добавить дополнительные изменения в предыдущую фиксацию(коммит) или изменить сообщение фиксации(коммита) 1, Вы можете использовать вместо этого git reset --soft HEAD~ , который похож на git reset HEAD~ 2 , но оставляет ваши существующие изменения поэтапными.
  3. Внесите исправления в файлы рабочего дерева.
  4. git add все, что вы хотите включить в свой новый коммит.
  5. Зафиксируйте изменения, повторно используя старое сообщение фиксации(коммита). reset скопировал старую головку в .git/ORIG_HEAD ; commit с помощью -c ORIG_HEAD откроет редактор, который изначально содержит сообщение журнала из старой фиксации(коммита) и позволяет редактировать его. Если вам не нужно редактировать сообщение, вы можете использовать опцию -C .

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

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

git push origin master --force

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

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

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


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

2HEAD~ — это то же самое, что и HEAD~1 . Кроме того, посмотрите, что такое HEAD в git? . Это полезно, если вы хотите отменить несколько коммитов.

Поделиться


Esko Luontola    

29 мая 2009 в 18:13



10880

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

Допустим, у вас есть это, где C-ваш HEAD и (F) — состояние ваших файлов.

   (F)
A-B-C
    ↑
  master

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

git reset --hard HEAD~1

В результате получается:

 (F)
A-B
  ↑
master

Теперь B-это HEAD. Поскольку вы использовали --hard , ваши файлы сбрасываются в свое состояние при фиксации(коммита) B.

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

   (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. Вы ничего не потеряли!

Для самого легкого прикосновения вы даже можете отменить свою фиксацию(коммит), но оставить свои файлы и индекс :

git reset --soft HEAD~1

Это не только оставляет ваши файлы в покое, но даже оставляет ваш индекс в покое. Когда вы сделаете git status , вы увидите, что в Индексе находятся те же файлы, что и раньше. На самом деле, сразу после этой команды вы могли бы сделать git commit , и вы бы повторили тот же самый коммит, который только что сделали.

Еще одна вещь: Предположим, вы уничтожаете коммит , как в первом примере, но затем обнаруживаете, что он вам все-таки нужен ? Не повезло, верно?

Нет, все еще есть способ вернуть его. Введите git reflog , и вы увидите список (частичных) коммитов shas (то есть хэшей), которые вы переместили. отменит последнее…



1761

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

git rm classdir
git add sourcedir

Затем внесите изменения в коммит:

git commit --amend

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

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

Поделиться


bdonlan    

29 мая 2009 в 18:16



1038

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 установит вашу рабочую копию в состояние фиксации(коммита) перед неправильной фиксацией(коммитом).

Поделиться


Lennart Koopmann    

29 мая 2009 в 18:13



793

Изменение последнего коммита

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

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

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

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

Поделиться


Zaz    

31 июля 2010 в 09:39



701

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

Чтобы получить фиксацию(коммит) ID, просто используйте git log .

Поделиться


Jaco Pretorius    

25 мая 2012 в 16:04



547

Если вы планируете полностью отменить локальную фиксацию(коммит), независимо от того, что вы изменили, вы сделали на фиксации(коммита), и если вы ничего не беспокоитесь об этом, просто выполните следующую команду. 1

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

git reset HEAD

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

Больше

Поделиться


Madhan Ayyasamy    

31 января 2013 в 07:06



515

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

Поделиться


nickf    

13 декабря 2011 в 10:18



481

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

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 [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>

Поделиться


neoneye    

06 апреля 2012 в 13:58



452

Я предпочитаю использовать 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 удалит коммиты для любой строки, которую вы удалите.

Поделиться


Steven Penny    

25 октября 2012 в 03:41



434

Как исправить предыдущую локальную фиксацию(коммит)

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

Как отменить предыдущую локальную фиксацию(коммит)

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

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

Как отменить публичную фиксацию(коммит)

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

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

git revert --no-edit HEAD

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

История фиксаций(коммитов) покажет оба коммита отдельно .


Дополнительно: коррекция

частной ветви в публичном репозитории

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

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

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

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

git push origin (branch_name)

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

Поделиться


Brent Bradburn    

23 апреля 2013 в 17:27



347

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

Идентификатор фиксации(коммита) можно увидеть с помощью

git log 

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

git reset --hard <commit_id>

git push origin <branch_name> -f

Поделиться


poorva    

17 мая 2013 в 13:02



345

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

git reset --soft HEAD~1

HEAD~1 -это сокращение от commit before head. В качестве альтернативы вы можете обратиться к SHA-1 из hash, если хотите сбросить значение. —soft option удалит фиксацию(коммит), но оставит все ваши измененные файлы «изменения, подлежащие фиксации(коммита)», как выразился бы git status.
git rm —cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

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

Поделиться


egridasov    

18 июля 2013 в 06:41


Похожие вопросы:

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

Я работал над чем-то и решил, что это полностью screwed…after, совершив некоторые из них. Поэтому я попробовал следующую последовательность: git reset —hard git rebase origin git fetch git pull…

Объедините локальные коммиты Git в один коммит для git-svn

В настоящее время, когда я запускаю git svn dcommit git, создается отдельный коммит в SVN для каждого локального коммита, который я сделал с момента последней синхронизации с SVN. Есть ли…

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

Я объединил удаленную ветвь в свое локальное РЕПО, и она создала 26 локальных коммитов. Теперь я хочу вернуть этот merge, но он думает, что довольно скучно и чувствительно к ошибкам возвращать…

git push, не нажимайте все локальные коммиты

Я новичок в git и сейчас тестирую его. На моей локальной машине я часто совершаю коммиты. Через определенные промежутки времени я хочу протолкнуть код в центральное РЕПО. В данный момент я публикую…

Git —bare … почему fetch не всегда показывает самые последние коммиты?

У меня есть несколько репо GIT, которые я зеркально отразил локально, чтобы показать в своем экземпляре JIRA, но я заметил некоторое (для меня) странное поведение. У меня есть РЕПО, мы назовем это…

Как удалить все локальные коммиты Git, которые я сделал?

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

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

Я работаю над деревом, которое имеет следующие коммиты:- aaaaaaa Implement function A bbbbbbb Implement function B ccccccc Implement function C Я хотел бы отменить первые два , то есть снова…

Как отменить коммиты в git

Я совершил два преступления и до сих пор не продвинулся. Как я могу отменить это, как будто я ничего не делал. Я всегда думал, что это сбросит его: git checkout master но это не сработало. Я также…

Как отменить последний git commit, если он также был первым?

Я знаю, что мы можем отменить вот так : как я могу отменить самые последние локальные коммиты в Git? Однако если коммит который мы хотим отменить является первым в проекте мы получили это сообщение…

Как перечислить самые последние 10 удаленных ветки в git

Я хочу получить самые последние 10 удаленных ветки, используя git. Я знаю, что могу использовать git branch -r —sort=-committerdate , чтобы получить все удаленные ветки отсортированный по…

Git: отменить merge

Есть репозиторий, с двумя бранчами — master и rdsmanager_NG-1.

Изменения в rdsmanager_NG-1 были смерджены в master.

Необходимо отменить это объединение.

Находим «лишний» мердж:

D:RDSrdsmanager>git log
commit d22654c64574d1f01ef49f12bf0688c7c9cc3c1d
Author: Your Name <[email protected]>
Date:   Wed Sep 2 00:42:05 2015 +0300

    11

commit 7bad6f70aa0d10717b55a141e9d85b4305ade67c
Author: User Name <[email protected]>
Date:   Tue Sep 1 17:52:05 2015 +0300

    NG-6727 RDSmanager user fix

В данном случае — коммит с ID d22654c64574d1f01ef49f12bf0688c7c9cc3c1d — не нужен.

Выполняем откат до предыдущего коммита:

D:RDSrdsmanager>git reset --hard 7bad6f70aa0d10717b55a141e9d85b4305ade67c
HEAD is now at 7bad6f7 NG-6727 RDSmanager user fix

Сохраняем изменения в самом репозитории:

D:RDSrdsmanager>git push --force origin master
Total 0 (delta 0), reused 0 (delta 0)
To [email protected] domain/rdsmanager.git
 + d22654c...7bad6f7 master -> master (forced update)

Готово:

D:RDSrdsmanager>git log
commit 7bad6f70aa0d10717b55a141e9d85b4305ade67c
Author: User Name <[email protected]>
Date:   Tue Sep 1 17:52:05 2015 +0300

    NG-6727 RDSmanager user fix

commit be299f2873ac3aa8f7b26c74914e65c022a82ddd
Author: User Name <[email protected]>
Date:   Tue Sep 1 17:50:46 2015 +0300

    NG-6727 RDSmanager user fix

Отмена отмены мерджа.

Создаём бранч заново, с ID коммита, который был отменён:

D:RDSrdsmanager>git branch -f rdsmanager_NG-1 d22654c64574d1f01e
D:RDSrdsmanager>git log
commit d22654c64574d1f01ef49f12bf0688c7c9cc3c1d
Author: Your Name <[email protected]>
Date:   Wed Sep 2 00:42:05 2015 +0300

    11

commit 7bad6f70aa0d10717b55a141e9d85b4305ade67c
Author: User Name <[email protected]>
Date:   Tue Sep 1 17:52:05 2015 +0300

    NG-6727 RDSmanager user fix

Все данные снова на месте.

f49f12bf0688c7c9cc3c1d

Проверяем:

D:RDSrdsmanager>git branch
* master
  rdsmanager_NG-1

Переключаемся на новый бранч, и проверяем:

D:RDSrdsmanager>git checkout rdsmanager_NG-1
Switched to branch 'rdsmanager_NG-1'
D:RDSrdsmanager>git log
commit d22654c64574d1f01ef49f12bf0688c7c9cc3c1d
Author: Your Name <[email protected]>
Date:   Wed Sep 2 00:42:05 2015 +0300

    11

commit 7bad6f70aa0d10717b55a141e9d85b4305ade67c
Author: user Name <[email protected]>
Date:   Tue Sep 1 17:52:05 2015 +0300

    NG-6727 RDSmanager user fix

Все изменения на месте.

Как это отменить?! Git-команды для исправления своих ошибок

Если вы ошиблись в Git’е, разобраться, что происходит и как это исправить, — непростая задача. Документация Git — это кроличья нора, из которой вы вылезете только зная конкретное название команды, которая решит вашу проблему.

Рассказываем о командах, которые помогут вам выбраться из проблемных ситуаций.

Вот блин, я сделал что-то не то… У Git ведь есть машина времени?!

git reflog
# Тут вы увидите всё, что вы делали
# в Git во всех ветках.
# У каждого элемента есть индекс [email protected]{index}.
# Найдите тот, после которого всё сломалось.
git reset [email protected]{index}
# Машина времени к вашим услугам.

Так вы можете восстановить то, что случайно удалили, и откатить слияние, после которого всё сломалось. reflog используется очень часто — давайте поблагодарим того, кто предложил добавить его в Git.

Я только что сделал коммит и заметил, что нужно кое-что поправить!

# Внесите изменения
git add . # или добавьте файлы по отдельности.
git commit --amend --no-edit
# Теперь последний коммит содержит ваши изменения.
# ВНИМАНИЕ! Никогда не изменяйте опубликованные коммиты.

Обычно эта команда нужна если вы что-то закоммитили, а потом заметили какую-то мелочь, например отсутствующий пробел после знака =. Конечно вы можете внести изменения новым коммитом, а потом объединить коммиты с помощью rebase -i, но это гораздо дольше.

Внимание Никогда не изменяйте коммиты в публичной ветке. Используйте эту команду только для коммитов в локальной ветке, иначе вам конец.

Мне нужно изменить сообщение последнего коммита!

git commit --amend
# Открывает редактор сообщений коммита.

Тупые требования к оформлению сообщений…

Я случайно закоммитил что-то в мастер, хотя должен был в новую ветку!

# Эта команда создаст новую ветку из текущего состояния мастера.
git branch some-new-branch-name
# А эта — удалит последний коммит из мастер-ветки.
git reset HEAD~ --hard
git checkout some-new-branch-name
# Теперь ваш коммит полностью независим :)

Команды не сработают, если вы уже закоммитили в публичную ветку. В таком случае может помочь git reset [email protected]{какое-то-количество-коммитов-назад} вместо HEAD~.

Ну отлично. Я закоммитил не в ту ветку!

# Отменяет последний коммит, но оставляет изменения доступными.
git reset HEAD~ --soft
git stash
# Переключаемся на нужную ветку.
git checkout name-of-the-correct-branch
git stash pop
# Добавьте конкретные файл или не парьтесь и закиньте все сразу.
git add .
git commit -m «Тут будет ваше сообщение»
# Теперь ваши изменения в нужной ветке.

Многие в такой ситуации предлагают использовать cherry-pick, так что можете выбрать, что вам больше по душе.

git checkout name-of-the-correct-branch
# Берём последний коммит из мастера.
git cherry-pick master
# Удаляем его из мастера.
git checkout master
git reset HEAD~ --hard

Я пытаюсь запустить diff, но ничего не происходит

Если вы знаете, что изменения были внесены, но diff пуст, то возможно вы индексировали изменения (через add). Поэтому вам нужно использовать специальный флаг.

git diff --staged

Конечно, «это не баг, а фича», но с первого взгляда это чертовски неоднозначно.

Мне нужно каким-то образом отменить коммит, который был сделан 5 коммитов назад

# Найдите коммит, который нужно отменить.
git log
# Можно использовать стрелочки, чтобы прокручивать список вверх и вниз.
# Сохраните хэш нужного коммита.
git revert  [тот хэш]
# Git создаст новый коммит, отменяющий выбранный.
# Отредактируйте сообщение коммита или просто сохраните его.

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

Помимо этого, откатить можно не целый коммит, а отдельный файл. Но следуя канону Git’а, это будут уже совсем другие команды…

Мне нужно отменить изменения в файле

# Найдите хэш коммита, до которого нужно откатиться. 
git log
# Сохраните хэш нужного коммита.
git checkout [тот хэш] --path/to/file
# Теперь в индексе окажется старая версия файла.
git commit -m «О май гадбл, вы даже не использовали копипаст»

Именно поэтому checkout — лучший инструмент для отката изменений в файлах.

Давай по новой, Миша, всё х**ня

cd ..
sudo rm -r fucking-git-repo-dir
git clone https://some.github.url/fucking-git-repo-dir.git
cd fucking-git-repo-dir

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

Будьте осторожны, эти команды разрушительны и необратимы.

# Получить последнее состояние origin.
git fetch origin
git checkout master
git reset --hard origin/master
# Удалить неиндексированные файлы и папки.
git clean -d --force
# Повторить checkout/reset/clean для каждой испорченной ветки.

***

Эти команды Git нужны для экстренных ситуаций, но пригодиться могут не только они. Про другие команды с пояснениями писали тут:

 

Перевод статьи «Oh Shit, Git!?!»

Как отменить последний коммит в GIT

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

Ситуация 1: Коммит плох, но не безнадежен

Ваши изменения еще не отправлены на сервер, но локально вы уже выполнили команду commit. Нужно как то отменить операцию и продолжить редактирование, чтобы потом все таки закоммитить.




Коммит будет отменен в локальной ветке, а файлы данного коммита окажутся в статусе «ожидают коммита» (to be commited).

Можете вносить правки.

Ситуация 2: Коммит безнадежен

Рассмотрим следующую ситуацию, когда последний коммит совсем никуда не годится, и лучше бы его вообще не было. Изменения были выполнены локально.

# случай 2: если нужно перейти к определенному коммиту

# смотрим его в истории ветки и переключаемся к нему

git log

git reset —hard abcdef0104938745498374897043

# дальше требуется заставить сервер принять это изменение

git push —force



git

Написать комментарий


Данная запись опубликована в 24.11.2018 16:17 и размещена в Программирование.
Вы можете перейти в конец страницы и оставить ваш комментарий.

Мало букафф? Читайте есчо !

Перезапись ветки данными из origin

Ноябрь 8, 2018 г.

Когда что то не просто пошло не так, а зашло слишком далеко, как восстановить состояние из удаленного репозитория (origin)?



Я прибегаю к этому методу, если эксперименты в очередной раз зашли в тупик, а
[crayon-6065b1c4accd7959155698/]
требует …

Читать

Тонкости настройки в .gitignore

Июль 17, 2017 г.

Настройки в файле .gitignore позволяют исключить из списка файлов сканируемых GIT, все то что отслеживать не надо. Обычно это так называемые юзер-файлы, изображения, архивы, документация и т.п.

В данной статье рассмотрим типовой случай настоек в .gitignore. …

Читать

Отмена действий в Git

Мы всегда готовы подчеркивать бесчисленные возможности, которые предлагает Git, и эта статья не станет исключением. Git известен своей потрясающей способностью отменять практически любые действия! Наверняка на память вам уже приходят тысячи печальных случаев, когда вы делали объединение, а потом понимали, что в ваши планы оно не входило. Даже если вам кажется, что ошибочное объединение— это величайшая неудача всей вашей жизни, сделайте глубокий вдох и дочитайте статью до конца.

Не существует какого-то одного традиционного способа отмены действий в Git. Отмена производится с помощью некоторых других команд. Мы рассмотрим “первую пятерку” сценариев, которые помогут вам исправить ошибку и двинуться дальше. 

Отмена Git Add

Один из самых распространенных вопросов в сообществе Git звучит так: “Как откатить git add перед коммитом?” Вы можете отменить действия над конкретным файлом или все внесенные изменения. 

Решение, которое потребуется для этого, весьма простое. Чтобы откатить один файл, просто вызовите команду git reset:

git reset <file>

Для отмены всех изменений запустите следующее:

git reset

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

Как откатить Git Merge

Объединение может привести к нежелаемым результатам. Но, как уже было сказано, вы можете с легкостью исправить свою ошибку! Давайте представим сценарий, в котором вы уже отправили изменения и осознали, что вам нужно отменить сделанное объединение.

Здесь на помощь приходит еще одна команда класса “отмена”: git revert. Начнем с того, что переключимся на мастер-ветку, используя команду git checkout:

git checkout master

Следующий шаг — запустить команду git log, чтобы получить ID сделанного объединения:

git log

Затем вернитесь к упомянутому коммиту, выполнив следующее:

git revert -m 1 <коммит объединения>

Используя -m 1 , вы даете Git указание: вернуться к первому родительскому элементу мастер-ветки, куда был совершен коммит объединения. Например, использование -m 2 сказало бы Git вернуться к первому родительскому элементу ветки, откуда пришел запрос на объединение.

Git также предлагает возможность предварительного просмотра, если вы хотите увидеть, что произойдет при объединении веток.  

Как откатить Git Reset

Предлагаем суперкороткий способ отменить команду git reset:

git reset ‘[email protected]{1}’

Следом можно запустить команду git reflog, чтобы просмотреть журнал всех обновлений (т.е. переключение веток, сброс, коммит, объединение). 

Отмена последних коммитов в Git

Существует несколько методов для отмены git commit. Давайте рассмотрим их по очереди.

Команду git reset можно использовать для отмены внесенных изменений:

git reset — soft HEAD~x (or git reset — soft commit hash).
git reset — soft HEAD~x

Вместо ~x введите число. Например, если вы укажете ~4, то команда повлияет на четвертый снизу коммит. Если вы не укажете никакое конкретно число, git reset — soft HEAD применится к последнему коммиту.

Когда вы используете команду git reset — soft HEAD, то просто отменяете последний коммит, при этом внесенные изменения останутся в вашем рабочем дереве и в вашем индексе. Поэтому git commit создаст в будущем коммит с теми же самыми изменениями, которые вы “обнулили” перед этим.

Другой метод — это команда git revert HEAD~x (git reset — hard commit hash), которая отменяет изменения, указанные последним коммитом в HEAD, и создает новый с возвращенными изменениями:

git revert HEAD ~x

Этот метод лучше всего работает в случае с общими публичными репозиториями.

Отмена Git Rebase

Допустим, вы выполнили команду git rebase в локальной ветке git и отправили ее в удаленную ветку. Следом вы поняли, что это не отвечает вашим ожиданиям, и захотели отменить сделанное. 

Самый простой способ  —  найти главный коммит вашей ветки, запустив команду:

git reflog

Следом необходимо установить туда текущую ветку, воспользовавшись git reset.

git reset — hard [email protected]{5}

В данном случае старым коммитом был HEAD5.

Заключение

Вот и все о том, как вы можете отменить наиболее часто используемые команды в Git. Хоть никакой традиционной команды отмены и нет, другие команды git могут помочь вам откатить то, что вы могли сделать по ошибке.

Читайте также:


Перевод статьи W3docs: Undoing in Git

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

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

Скажем, у вас это есть, где 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 — это просто указатель на последний коммит. Когда вы делаете a git reset HEAD~1, вы говорите Git переместить указатель HEAD на один коммит. Но (если вы не используете --hard) вы оставляете свои файлы, как они были. Итак, теперь git statusпоказывает изменения, которые вы зарегистрировали в C. Вы ничего не потеряли!

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

git reset --soft HEAD~1

Это не только оставляет ваши файлы в покое, но даже оставляет ваш индекс в покое. Когда вы это сделаете git status, вы увидите, что в индексе есть те же файлы, что и раньше. Фактически, сразу после этой команды вы могли бы выполнить git commitи повторить тот же коммит, который только что сделал.

Еще одна вещь: предположим, вы уничтожили коммит, как в первом примере, но потом обнаружили, что он вам нужен в конце концов ? Не повезло, правда?

Нет, еще есть способ вернуть его. Тип git reflogи вы увидите список (частично) совершать ШАС (то есть, хэш) , что вы переместились вокруг в Найти коммит вы уничтожили, и сделать это.:

git checkout -b someNewBranchName shaYouDestroyed

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

Как отменить последнюю фиксацию Git — devconnected

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

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

Иногда может потребоваться внести дополнительные изменения перед выполнением фиксации.

Как следствие, вам нужно отменить последнюю фиксацию из вашего репозитория Git.

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

Отменить последнюю фиксацию Git со сбросом

Самый простой способ отменить последнюю фиксацию Git — выполнить команду «git reset» с опцией «–soft», которая сохранит изменения, внесенные в ваши файлы. Вы должны указать фиксацию, которую нужно отменить, в данном случае это «HEAD ~ 1».

Последний коммит будет удален из вашей истории Git.

  $ git reset - soft HEAD ~ 1  

Если вы не знакомы с этой записью, «HEAD ~ 1» означает, что вы хотите сбросить HEAD (последнюю фиксацию) на одну фиксацию раньше в истории журнала.

  $ git журнал --oneline

3fad532 Последняя фиксация (HEAD)
3bnaj03 Коммит перед HEAD (HEAD ~ 1)
vcn3ed5 Две фиксации перед HEAD (HEAD ~ 2)  

Итак, каково влияние этой команды?

Команду «git reset» можно рассматривать как команду , противоположную команде «git add» , которая, по сути, добавляет файлы в индекс Git.

При указании опции «–soft» Git получает указание не изменять файлы в рабочем каталоге или в индексе вообще.

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

  $ git log --oneline --graph

* b734307 (HEAD -> master) Добавлен новый файл с именем "file1"
* 90f8bb1 Вторая фиксация
* 7083e29 Начальная фиксация репозитория  

Как следствие, вы будете использовать «git reset» с опцией «–soft» для того, чтобы отменить последнюю фиксацию и выполнить дополнительные изменения.

  $ git reset - мягкая ГОЛОВКА ~ 1

$ git status

О мастере филиала
Ваша ветка опережает origin / master на 1 коммит.
  (используйте "git push" для публикации ваших локальных коммитов)

Изменения, которые необходимо зафиксировать:
  (используйте "git restore --staged  ..." для отмены постановки)
        новый файл: file1

$ git log --oneline --graph

* 90f8bb1 (HEAD -> master) Вторая фиксация
* 7083e29 Начальная фиксация репозитория  

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

Замечательно, вы успешно отменили последнюю фиксацию Git в своем репозитории.

Аппаратный сброс Git commit

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

В некоторых случаях вы просто хотите избавиться от фиксации и изменений, внесенных в файлы.

Это назначение опции «–hard».

Чтобы отменить последнюю фиксацию и отменить все изменения в рабочем каталоге и индексе, выполните команду «git reset» с параметром «–hard» и укажите фиксацию перед HEAD («HEAD ~ 1»).

  $ git reset --hard HEAD ~ 1  

Будьте осторожны при использовании «–hard»: изменения будут удалены из рабочего каталога и индекса, вы потеряете все изменения.

Возвращаясь к примеру, который мы подробно описали ранее, предположим, что вы зафиксировали новый файл в своем репозитории Git с именем «file1».

  $ git log --oneline --graph

* b734307 (HEAD -> master) Добавлен новый файл с именем "file1"
* 90f8bb1 Вторая фиксация
* 7083e29 Начальная фиксация репозитория  

А теперь представим, что вы хотите отменить последнюю фиксацию и отменить все изменения.

  $ git reset --hard HEAD ~ 1

HEAD теперь находится на 90f8bb1 Вторая фиксация  

Отлично, теперь давайте посмотрим на состояние нашего репозитория Git.

  $ git status

О мастере филиала
В вашей ветке обновлены сведения о происхождении / мастере
  (используйте "git push" для публикации ваших локальных коммитов)

ничего не делать, рабочее дерево чистое  

Как видите, файл был полностью удален из репозитория Git (индекс + рабочий каталог)

Смешанный сброс Git commit

Чтобы отменить последнюю фиксацию Git, сохраняйте изменения в рабочем каталоге, но НЕ в индексе, вы должны использовать команду «git reset» с параметром «–mixed».Рядом с этой командой просто добавьте «HEAD ~ 1» для последней фиксации.

  $ git reset - смешанная ГОЛОВКА ~ 1  

В качестве примера предположим, что мы добавили файл с именем «file1» в фиксацию, которую нам нужно отменить.

  $ git log --oneline --graph

* b734307 (HEAD -> master) Добавлен новый файл с именем "file1"
* 90f8bb1 Вторая фиксация
* 7083e29 Начальная фиксация репозитория  

Чтобы отменить последнюю фиксацию, мы просто выполняем команду «git reset» с параметром «–mixed».

  $ git reset - смешанная ГОЛОВКА ~ 1  

При указании опции «–mixed» файл будет удален из индекса Git, но не из рабочего каталога.

Как следствие, «–mixed» — это «смесь» между программным и аппаратным сбросом, отсюда и его название.

  $ git status

О мастере филиала
Ваша ветка опережает origin / master на 1 коммит.
  (используйте "git push" для публикации ваших локальных коммитов)

Неотслеживаемые файлы:
  (используйте "git add  ..." для включения в то, что будет зафиксировано)
        file1

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

Отлично! Вы нашли другой способ отменить последнюю фиксацию при сохранении изменений, сделанных в файлах.

В следующем разделе мы увидим еще один способ отменить последнюю фиксацию с помощью команды git revert .

Отменить последнюю фиксацию с возвратом

Чтобы отменить последний коммит Git, используйте «git revert» и укажите коммит, который нужно отменить, то есть «HEAD» для последнего коммита в вашей истории.

  $ git revert HEAD  

Команда «git revert» немного отличается от команды «git reset», потому что будет записывать новую фиксацию с изменениями, внесенными путем отката последней фиксации.

Также обратите внимание, что с «git reset» вы указали «HEAD ~ 1», потому что команда сброса устанавливает новую позицию HEAD, а возврат фактически отменяет указанную фиксацию.

Как следствие, вам придется снова зафиксировать изменения, чтобы файлы были отменены, а фиксация была отменена.

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

  $ git log --oneline --graph

* b734307 (HEAD -> master) Добавлен новый файл с именем "file1"
* 90f8bb1 Вторая фиксация
* 7083e29 Начальная фиксация репозитория  

При выполнении команды «git revert» Git автоматически откроет ваш текстовый редактор, чтобы зафиксировать изменения.

Когда вы закончите с сообщением о фиксации, отобразится сообщение с новым хешем фиксации.

  [master 2d40a2c] Вернуть "Добавлен новый файл с именем file1"
 1 файл изменен, 1 удален (-)
 режим удаления 100644 файл1  

Теперь, если бы вы снова проверили свою историю Git, вы бы заметили, что была добавлена ​​новая фиксация, чтобы отменить последнюю фиксацию из вашего репозитория.

  $ git log --oneline --graph

* 2d40a2c (HEAD -> master) Вернуть "Добавлен новый файл с именем file1"
* 1fa26e9 Добавлен новый файл с именем file1
* ee8b133 Вторая фиксация
* a3bdedf Начальная фиксация  

Заключение

В этом руководстве вы увидели все способы отмены последней фиксации вашего репозитория Git.

Вы узнали о команде « git reset » и различных способах ее выполнения в зависимости от того, что вы хотите сохранить или нет.

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

Если вам интересно узнать о Git или о разработке программного обеспечения, у нас есть полный раздел, посвященный этому, на веб-сайте, поэтому обязательно ознакомьтесь с ним!

Если вам нравится Git, возможно, вам понравятся наши другие статьи:

Контроль версий

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

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

вариант 1:

git reset --hard

Допустим, у вас есть это, где C — это ваш HEAD, а (F) — это состояние ваших файлов.

  (Ж)
А-В-С
    ↑
  мастер
  

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

  git reset --hard HEAD ~ 1
  

Результат:

  (Ж)
А-Б
  ↑
мастер
  

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

вариант 2:

git reset

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

  (Ж)
А-В-С
    ↑
  мастер
  

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

  git сбросить HEAD ~ 1
  

В данном случае результат:

  (Ж)
А-В-С
  ↑
мастер
  

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

вариант 3:

git reset - soft

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

  git reset - мягкая ГОЛОВКА ~ 1
  

Это не только оставляет ваши файлы в покое, но и оставляет в покое ваш индекс . Когда вы выполните git status , вы увидите, что в индексе находятся те же файлы, что и раньше. Фактически, сразу после этой команды вы можете выполнить git commit и повторить только что сделанную фиксацию.

вариант 4: вы выполнили

git reset --hard и вам нужно вернуть этот код

Еще одна вещь: Предположим, вы уничтожили фиксацию , как в первом примере, , но потом обнаруживаете, что она вам все-таки нужна? Не повезло, правда?

Неа, есть еще способ вернуть.Введите git reflog , и вы увидите список (частичных) SHA-кодов фиксации (то есть хэшей), в которые вы переместились. Найдите уничтоженную фиксацию и сделайте следующее:

  git checkout -b someNewBranchName shaYouDestroyed
  

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

как отменить последнюю фиксацию в git

как отменить последнюю фиксацию в git — qaru

Присоединяйтесь к Stack Overflow , чтобы учиться, делиться знаниями и строить свою карьеру.

Спросил

Просмотрено
235k раз

На этот вопрос уже есть ответы :

Закрыт 4 года назад.

По ошибке я сделал git add. и git commit в ветке разработки development . Но, к счастью, я не сделал git push .

Итак, я хотел вернуть его в исходное состояние.

Я пробовал git reset --soft и git reset HEAD --hard , но похоже, что я все испортил.

Как мне это исправить? Я хочу вернуться в исходное состояние и, возможно, сохранить изменения кода.

рыдать

8,39322 золотых знака3535 серебряных знаков6565 бронзовых знаков

задан 24 мая ’16 в 20: 552016-05-24 20:55

chintan schintan s

4,9521313 золотых знаков3939 серебряных знаков7070 бронзовых знаков

0

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

Создан 24 май 2016, в 21:02

угадывать

7,53511 золотых знаков1515 серебряных знаков2323 бронзовых знака

10

Попробуйте просто сбросить последнюю фиксацию с помощью флага --soft

  git reset - мягкая ГОЛОВКА ~ 1
  

Примечание :

Для Windows заключите части HEAD в кавычки, например git reset --soft "HEAD ~ 1"

Создан 24 май 2016, в 21:01

Всегда солнечно, всегда солнечно

28. 5k66 золотых знаков4141 серебряный знак7171 бронзовый знак

3

Stack Overflow лучше всего работает с включенным JavaScript

Ваша конфиденциальность

Нажимая «Принять все файлы cookie», вы соглашаетесь с тем, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в ​​отношении файлов cookie.

Принимать все файлы cookie

Настроить параметры

Как отменить несколько коммитов git?

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

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

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

У вас такая ситуация:

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

(стрелки здесь относятся к направлению указателя: «родительская» ссылка в случае фиксации, верхняя фиксация в случае заголовка ветки (ссылка ветки) и имя ветки в случае ссылки HEAD).-1] означает фиксацию, которая отменяет изменения в коммитах B, C, D. Математика говорит нам, что (BCD) -1 = D -1 C -1 B -1 , поэтому вы можете получить требуемую ситуацию с помощью следующих команд:

  $ git revert --no-commit D
$ git revert --no-commit C
$ git revert --no-commit B
$ git commit -m "сообщение о фиксации для всех"
  

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


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

  $ git checkout -f A -. # проверить эту ревизию поверх локальных файлов
$ git commit -a
  

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

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

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


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

  $ git reset --hard A
$ git reset --soft D # (или ORIG_HEAD или @ {1} [предыдущее расположение HEAD]), все из которых D
$ git commit
  

Git Revert | Учебник Atlassian Git

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

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

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

  $ mkdir git_revert_test 
$ cd git_revert_test /
$ git init.
Инициализированный пустой репозиторий Git в /git_revert_test/.git/
$ touch demo_file
$ git add demo_file
$ git commit -am "initial commit"
[master (root-commit) 299b15f] initial commit
1 файл изменен, 0 вставок (+), 0 удалений (-)
режим создания 100644 demo_file
$ echo "начальное содержимое" >> demo_file
$ git commit -am "добавить новый контент в демонстрационный файл"
[master 3602d88] добавить новый контент в демонстрационный файл
n 1 файл изменен, 1 вставка (+)
$ echo "prepended line content" >> demo_file
$ git commit -am "добавить содержимое к демонстрационному файлу"
[master 86bb32e] добавить содержимое к демонстрационному файлу
1 файл изменен, 1 вставка (+)
$ git log --oneline
86bb32e добавить контент в демонстрационный файл
3602d88 добавить новый контент в демонстрационный файл
299b15f начальная фиксация

Здесь мы инициализировали репо во вновь созданном каталоге с именем git_revert_test .Мы сделали 3 коммита в репо, в которые добавили файл demo_file и дважды изменили его содержимое. В конце процедуры настройки репо мы вызываем git log , чтобы отобразить историю коммитов, всего 3 коммита. Когда репо находится в этом состоянии, мы готовы инициировать откат git.

  $ git revert HEAD [master b9cd081] Отменить «добавить содержимое в демонстрационный файл» 1 файл изменен, 1 удален (-)  

Git revert ожидает, что ссылка на фиксацию была передана, и не будет выполняться без нее. Здесь мы прошли HEAD ref. Это вернет последнюю фиксацию. Это такое же поведение, как если бы мы вернулись к фиксации 3602d8815dbfa78cd37cd4d189552764b5e96c58 . Подобно слиянию, откат создаст новую фиксацию, которая откроет настроенный системный редактор с запросом нового сообщения фиксации. Как только сообщение фиксации будет введено и сохранено, Git возобновит работу. Теперь мы можем проверить состояние репо с помощью git log и увидеть, что в предыдущий журнал добавлена ​​новая фиксация:

  $ git log --oneline 1061e79 Отменить «добавить содержимое в демонстрационный файл» 86bb32e добавить содержимое в демонстрационный файл 3602d88 добавить новое содержимое в демонстрационный файл 299b15f начальная фиксация 

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

Общие опции

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

Это инверсия опции -e .Откат не откроет редактор.

Сброс против возврата

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

Git Revert Push Commit: как отменить последнюю фиксацию

В этом посте я покажу, как я иногда восстанавливаю неправильные изменения (коммиты) в проекте кодирования, используя git в командной строке.

Зачем мне это нужно?

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

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

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

  корень @ debian: / home / debian / test-project # git log
commit <хэш последней фиксации>
Автор: Изабель Коста 
Дата: 4 февраля, 21:57:40 2018 +0000

<сообщение фиксации>

commit <хеш перед последней фиксацией>
Автор: Изабель Коста 
Дата: 4 февраля, 21:42:26 2018 +0000

<сообщение фиксации>

(...)
  

Вы также можете запустить git log --oneline , чтобы упростить вывод:

  корень @ debian: / home / debian / test-project # git log --oneline
<хэш последней фиксации> <сообщение фиксации>
cdb76bf Добавлена ​​еще одна функция
d425161 Добавлена ​​одна функция

(...)
  

Чтобы протестировать конкретную фиксацию (например: <хеш последней фиксации> ), которая, по вашему мнению, имеет последнюю рабочую версию, вы можете ввести следующее:

  git checkout <хеш фиксации>
  

Это заставит рабочий репозиторий соответствовать состоянию этой точной фиксации.

После этого вы получите следующий результат:

  root @ debian: / home / debian / test-project # git checkout <хеш фиксации>
Примечание: проверка ''.Вы находитесь в состоянии «отключенная ГОЛОВА». Вы можете осмотреться, внести экспериментальные изменения
и зафиксировать их, и вы можете отказаться от любых коммитов, сделанных в этом состоянии, без
воздействуя на любые ветки, выполняя еще одну проверку. 

Если вы хотите создать новую ветку для сохранения созданных вами коммитов, вы можете сделать это
(сейчас или позже), снова используя -b с командой checkout. Пример:

git checkout -b имя_новой_ветки

HEAD теперь находится в <хеш фиксации> ... <сообщение фиксации>
  

После анализа конкретной фиксации, если вы затем решите остаться в этом состоянии фиксации, вы можете отменить последнюю фиксацию.

Как отменить эту фиксацию?

Если вы хотите отменить / отменить последнюю фиксацию, вы можете сделать следующее, используя хэш фиксации, который вы получаете из команды git log :

Эта команда создаст новую фиксацию со словом «Вернуть» в начале сообщения. После этого, если вы проверите статус своего репозитория, вы заметите, что HEAD отсоединен от коммита, который вы тестировали ранее.

  корень @ debian: / home / debian / test-project # git status
ГОЛОВА отделена на 69d885e

(...)
  

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

  git checkout <текущая ветка>
  

Во время написания этого поста я нашел этот учебник - Отмена коммитов и изменений - от Atlassian, который очень хорошо описывает эту проблему.

Резюме

  • Если вы хотите протестировать предыдущую фиксацию, просто выполните git checkout ; затем вы можете протестировать последнюю рабочую версию вашего проекта.

  • Если вы хотите отменить последнюю фиксацию, просто выполните git revert <нежелательный хэш фиксации> ; затем вы можете нажать эту новую фиксацию, которая отменила вашу предыдущую фиксацию.

  • Чтобы исправить оторвавшуюся голову, выполните git checkout <текущая ветка> .


Вы можете найти меня в Twitter, LinkedIn, Github, Medium и на моем личном веб-сайте.

Отменить изменения в репозитории Git - WebStorm

Отменить незафиксированные изменения

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

  • В окне инструмента фиксации Alt + 0 выберите одно или несколько файлы, которые вы хотите восстановить, и выберите Откат в контекстном меню или нажмите Ctrl + Alt + Z .Все изменения, внесенные в выбранные файлы с момента последней фиксации, будут отменены, и они исчезнут из активного списка изменений.

Отменить последнюю фиксацию

WebStorm позволяет вам отменить последнюю фиксацию в текущей ветке.

Вы не можете отменить фиксацию, если она была отправлена ​​в защищенную ветку, то есть ветвь, для которой принудительное использование --push не разрешено (настройте защищенные ветки в диалоговом окне «Настройки / Предпочтения» Ctrl + Alt + S в разделе «Контроль версий | Git) Обратите внимание, что если ветка помечена как защищенная на GitHub, WebStorm автоматически помечает ее как защищенную, когда вы ее проверяете.

  1. Откройте окно инструмента Git Alt + 9 и перейдите на вкладку Журнал.

  2. Выберите последнюю фиксацию в текущей ветке и выберите «Отменить фиксацию» в контекстном меню.

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

  4. Выберите опцию Установить активным, если вы хотите сделать список изменений с изменениями, которые вы собираетесь отменить, активным списком изменений.

  5. Выберите параметр «Отслеживать контекст», если вы хотите, чтобы WebStorm запомнил ваш контекст и перезагружал текущие открытые файлы в редакторе, когда этот список изменений становится активным.

Отменить отправленную фиксацию

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

  1. Найдите фиксацию, которую нужно отменить, на вкладке «Журнал» в окне инструмента Git Alt + 9 , щелкните ее правой кнопкой мыши и выберите «Отменить фиксацию» в контекстном меню. Этот параметр также доступен из контекстного меню фиксации в представлении истории файла. Откроется диалоговое окно «Фиксация изменений» с автоматически созданным сообщением фиксации.

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

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

  3. Нажмите «Принять», чтобы зафиксировать набор изменений, который отменяет изменения в выбранных файлах в этой конкретной фиксации.

Отменить выбранные изменения

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

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

  2. На панели «Измененные файлы» щелкните правой кнопкой мыши файл, который нужно восстановить, и выберите «Вернуть выбранные изменения» в контекстном меню.

    Это приводит к новой фиксации, которая отменяет изменения, которые вы хотите отменить.

Отбросить фиксацию

В отличие от отмены фиксации, которая отражается в истории веток, вы можете отменить нажатую фиксацию в текущей ветке, не оставляя следов операции.

Как и любая операция, которая перезаписывает историю ветвей, для удаления фиксации требуется нажатие --force, и ее нельзя выполнить в защищенных ветвях (их можно настроить в диалоговом окне «Настройки / Предпочтения» Ctrl + Alt + S в разделе «Контроль версий | Git»). .

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

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

  1. Откройте окно средства управления версиями Alt + 9 и перейдите на вкладку «Журнал».

  2. Выберите фиксацию, на которую вы хотите переместить HEAD, и выберите «Сбросить текущую ветку сюда» из контекстного меню.

  3. В открывшемся диалоговом окне Git Reset выберите способ обновления рабочего дерева и индекса и нажмите Reset:
    • Soft: все изменения из коммитов, которые были сделаны после выбранной фиксации, будут поэтапными (это означает, что они будут перемещены в представление «Локальные изменения», чтобы вы могли просмотреть их и при необходимости зафиксировать позже).

    • Смешанный: изменения, сделанные после выбранной фиксации, будут сохранены, но не будут подготовлены для фиксации.

    • Жесткий: все изменения, сделанные после выбранной фиксации, будут отменены (как поэтапные, так и зафиксированные).

    • Сохранить: зафиксированные изменения, сделанные после выбранной фиксации, будут отброшены, но локальные изменения останутся нетронутыми.

Получить предыдущую ревизию файла

Если вам нужно вернуть один файл вместо отмены всей фиксации, которая включает изменения в несколько файлов, вы можете вернуться к конкретной версии этого файла:

  1. Выберите нужный файл в любом представлении (в окне инструмента «Проект», в редакторе, в представлении «Локальные изменения» и т.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

2021 © Все права защищены. Карта сайта