wwwoldi.ru

About Me

Dashy

Hello word I am dashy Guy

Разное

Отменить все изменения git: GIT. Отменить локальные изменения / Тяпк

alexxlab
No Comments

Содержание

Отмена изменений в Git – Zencoder

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

Эта тема касается отмены изменений в Git. Так как эта система контроля версий представляет из себя три ветки — рабочая директория, буфер, репозиторий — то будут рассмотрены все три способа.

Отмена изменений в рабочей директории

Для отмены изменений в рабочей директории необходимо выполнить одну команду:

git checkout -- name_of_file

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

Обязательным условием использования команды является двойной дефис. Это “говорит” команде , что в данном случае нужно оставаться в текущей ветке (branche).

Отмена изменений в буфере

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

git reset HEAD name_of_file

Эта команда “вернет” файл из буфера в рабочую директорию.

Отмена изменений в репозитории

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

Нельзя просто так взять и изменить какой-либо определенный коммит — все они находятся в своеобразной цепочке и один коммит проистекает из предыдущего коммита.

Другими словами, у каждого коммита есть свой коммит-родитель и коммит-потомок. Изменить какой-либо коммит — это значит вырвать его из этой цепочки взаимосвязей. Тем самым нарушится целостность всего репозитория и работа Git также нарушится. Ведь дело в том, что сама суть системы контроля версий Git основана на такой взаимосвязанной цепочке коммитов — один коммит проистекает из другого, второй из первого, третий из второго и так далее.

Как же поступить в данной ситуации?

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

Опция amend

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

Соответственно, раз у этого коммита нет потомков, то изменение этого коммита не повлечет за собой нарушение целостности всей цепочки коммитов. Измениться только этот коммит — и только.

Изменить крайний коммит можно просто перезаписав его. Для этой цели служит ключ . Команда в целом представляет из себя следующее:

git commit --amend -m "Add some commit"

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

Команда checkout

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

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

Команда может заставить указатель HEAD вернуться назад, на предыдущее место остановки — на предыдущий коммит. И необязательно этот коммит должен быть предыдущим — он может быть любым более ранним.

Все что для этого нужно — это указать тот коммит, к которому должен вернуться HEAD. Указать коммит просто — у каждого коммита есть уникальный идентификатор — контрольная SHA-сумма.

Команда возврата к нужному коммиту выглядит таким образом:

git checkout -- 4a2f59a32bd1074c42 name_of_file

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

И тогда Git произведет сброс состояния (которые были сделаны в последнем коммите) файла в буфер. Если ввести команду то увидим, что в буфере будут изменения, готовые для коммита. Это те самые изменения файла , которые мы “выбросили” из репозитория.

Дальше выполняем “выброс” изменений файла из буфера в рабочую директорию, чтобы мы смогли внести правки в этот файл:

git reset HEAD name_of_file

Все, что будет внесено в этот файл, а затем закоммичено — будет иметь уже другую контрольную сумму. А следовательно — это уже будет совсем другой коммит.

Зеркалирование коммитов

Одной из разнообразных команд Git для внесения изменений в репозиторий является команда .

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

Синтаксис команды revert также прост:

git revert 4a2f59a32bd1074c42

где — это часть SHA-суммы крайнего коммита.

Команда reset

Команда также может изменять репозиторий Git. Делает она это путем смещения указателя HEAD на нужный коммит.

После такого смещения HEAD все более поздние коммиты никуда не пропадут из репозитория — они все еще там. Но теперь любое закоммиченное изменение произведет перезапись более поздних коммитов — и тогда они будут потеряны навсегда.

Ситуация очень похожа на то образное сравнение цепочки коммитов Git с магнитофонной лентой. Стоит отмотать ленту на 10-20 минут назад и снова начать запись, то все более поздние записи (относительно этого места) будут перезаписаны.

У команды есть три ключа, которые незначительно видоизменяют ее работу:

Команда 

1

git reset --soft 4a2f59a32bd1074c42

произведет смещение указателя HEAD на указанный коммит 4a2f59a32bd1074c42. При этом Git произведет сброс изменений в буфер. В результате буфер и рабочая директория будут идентичными между собой; а репозиторий будет переведен в более ранее состояние.

Команда 

1

git reset --mixd 4a2f59a32bd1074c42

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

Команда 

1

git reset --hard 4a2f59a32bd1074c42

самая “жесткая”. Также будет произведено смещение указателя HEAD на указанный коммит, но при этом будет произведен сброс всех трех деревьев Git — репозитория, буфера и рабочей директории. Все три будут идентичными друг другу.

Команда clean

В системе Git существует команда для удаления не отслеживаемых файлов в рабочей директории.

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

Команда как раз и выполняет очистку мусора в системе. Она удаляет все не отслеживаемые и неиспользуемые файлы.

Но даже это она делает очень осторожно. Если просто запустить , то ничего не произойдет. Система Git скажет, что команду необходимо запускать либо с ключом , либо с ключом .

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

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

На этом все.

git

Как отменить commit и не облажаться / Хабр

Не только разработчикам-новичкам, но и ярым профессионалам приходится прибегать к отмене каких-либо изменений. И тогда, первое, что приходит на ум, — это команда git revert, как самый безопасный способ. И тут есть подводные камни, про которые я хочу рассказать.

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

  • Реализовать арифметические операции (сложение, вычитание, деление и т.д.)

  • Реализовать числовые операции (максимальное значение, минимальное значение, модуль числа и т.д.)

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

Рассмотрим дерево коммитов. Видим, что наш разработчик создал ветку functions, класс Arithmetic, отвечающий за реализацию арифметических операций (коммит А), и класс Numerical, отвечающий за реализацию числовых операций (коммит N). Итого два класса и два коммита.

git revert

Решено, дабы ничего не переписывать, наследоваться от functions и создать две ветки numerical и arithmetic. И соответственно отменить ненужные коммиты. То есть выполнить git revert N в ветке arithmetic и git revert A в ветке numerical. Гениально и просто!

Работа кипит и осталось дело за малым — смерджить мастер с данными ветками.

И что же мы получили? Ни класса Arithmetic, ни класса Numerical!

А все дело в том, что команда git revert создает новый коммит с отменой изменений и не удаляет из истории коммиты. И в нашем случае после слияния веток получается 4 коммита:

A ⟶ N ⟶ revert A ⟶ revert N

То есть вариант с отменой изменений с помощью команды revert вышел нам боком.

git reset

И тут мы вспоминаем, что есть такая команда как reset, вот она в отличии от revert точно удаляет коммиты из истории. Но есть одно НО… она сбрасывает все коммиты до указанного. Такое поведение нам не подходит, так как мы хотим выбрать какие коммиты удалить.

git rebase

Есть еще одно решение — использовать команду git rebase для отмены изменений.

Вернемся к моменту создания двух веток numerical и arithmetic и выполним

git rebase -i –root

Теперь на уровне каждого коммита, который мы хотим отменить заменим pick на drop. И тогда выбранные нами коммиты сбросятся из истории. Например в ветке numerical:

Тогда в истории у нас останутся только нужные нам коммиты.

Теперь при слиянии веток в master получим оба класса.

Данный метод рабочий, только при условии работы в частной ветке, но если эти манипуляции провести в общей ветке, то при публикации (git push) git сообщает, что ветка устарела, так как в ней отсутствуют коммиты и отменяет публикацию.

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

Отмена изменений в GIT

Случай, который происходит довольно редко, но метко — это «Ааааа, я накосячил в git!!!». У меня случилось такое сегодня, когда я сделал rebase со squash’ем локальной ветки, не имея этих коммитов в другой ветке. Git не задумываясь слил мои коммиты в один и перенёс его, а мне нужно было сохранить исходную ветку, создав новый squash-коммит.

В общем, здесь я вспомнил про логи и отмену изменений. Git умеет отменять практически любые изменения. Все связанное с передвижением HEAD’а можно отменить reset’ом. В моём случае отмена rebase делается следующим способом…

Смотрим последние изменения (безопасно):

git reflog # для выхода жмем q
# или смотреть последние 10 действий
git reflog -n 10
# или тоже самое, но короче
git reflog -10

Например, мой вывод

$ git reflog -n 6
703952e HEAD@{0}: rebase -i (finish): returning to refs/heads/BPN-3546
703952e HEAD@{1}: rebase -i (squash): BPN-3546 Add content type for Gauge in Drupal
9a23f7e HEAD@{2}: rebase -i (squash): # This is a combination of 2 commits.
c1b984f HEAD@{3}: rebase -i (pick): BPN-3546 Add content type for Gauge in Drupal
c6be61c HEAD@{4}: rebase -i (start): checkout refs/heads/Gauge
cf81cc3 HEAD@{5}: commit (amend): BPN-3546 Add content type for Gauge in Drupal

Дальше находим необходимую точку и откатываем код до её состояния. Здесь я вижу, что последние 5 чекпоинтов связаны с ребейзом. Я их пропускаю и двигаю HEAD назад на 6 изменений.

Здесь нужно понимать, что нельзя отменить какое-то одно, определённое действие совершённое ранее (если оно не последнее в истории). Можно лишь вернуться в фиксированную точку во времени, отменив все действия от текущего момента.

Флаг --hard будет означать, что добавленные изменения будут удалены.
Например, если вы откатываете коммит, в котором добавили файл, то после отката этот файл будет удалён из репозитория.Здесь можно использовать флаг --soft, который означает, что после отката коммита файл останется как не зафиксированные изменения.

git reset --hard HEAD@{5}
# для Windows могут понадобиться кавычки
git reset --hard "HEAD@{5}"

Полезные ссылки

git отменить все незафиксированные или несохраненные изменения — git

Я пытаюсь отменить все изменения, произошедшие со времени моего последнего коммита. Я попробовал git reset --hard и git reset --hard HEAD после просмотра этого поста . Я отвечаю с головой теперь на 18c3773… но когда я смотрю на свой локальный источник, все файлы все еще там. Что я упускаю из виду?

git

command-line

undo

git-reset

Поделиться

Источник


Antarr Byrd    

28 декабря 2012 в 20:46

6 Ответов


1345

  • Это приведет к удалению всех файлов, которые вы могли бы поместить с git add :

    git reset

  • Это приведет к отмене всех локальных незафиксированных изменений (должны быть выполнены в корневом РЕПО):

    git checkout .

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

    git checkout [some_dir|file.txt]

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

    git reset --hard HEAD

  • Это приведет к удалению всех локальных неотслеживаемых файлов, так что останется только git отслеживаемых файлов:

    git clean -fdx

    WARNING: -x также удалит все игнорируемые файлы, включая те, которые указаны в .gitignore ! Вы можете использовать -n для предварительного просмотра удаляемых файлов.

Подводя итог: выполнение приведенных ниже команд в основном эквивалентно fresh git clone из исходного кода (но он ничего не перекачивает, поэтому намного быстрее):

git reset
git checkout .
git clean -fdx

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

Поделиться


mvp    

28 декабря 2012 в 21:04


127

Если вы хотите «отменить» все незафиксированные изменения, просто запустите:

git stash
git stash drop

Если у вас есть какие-либо неотслеживаемые файлы (проверьте, запустив git status ), они могут быть удалены при запуске:

git clean -fdx

git stash создает новый тайник, который станет stash@{0} . Если вы хотите проверить сначала, вы можете запустить git stash list , чтобы увидеть список ваших тайников. Это будет выглядеть примерно так:

stash@{0}: WIP on rails-4: 66c8407 remove forem residuals
stash@{1}: WIP on master: 2b8f269 Map qualifications
stash@{2}: WIP on master: 27a7e54 Use non-dynamic finders
stash@{3}: WIP on blogit: c9bd270 some changes

Каждый тайник назван в честь предыдущее сообщение.

Поделиться


Abram    

18 июля 2014 в 20:59


18

существует также git stash -which «stashes» ваши локальные изменения и может быть повторно применен в более позднее время или удален, если больше не требуется

больше информации о тайниках

Поделиться


keshav    

28 декабря 2012 в 21:17


11

Я использую исходное дерево…. Можно ли отменить все несохраненные изменения в 2 простых шага:

1) просто нужно сбросить статус файла рабочего пространства

2) Выберите все файлы unstage (command +a), щелкните правой кнопкой мыши и выберите Удалить

Это так просто 😀

Поделиться


user1872384    

14 июля 2016 в 17:19


5

Для тех, кто добрался сюда в поисках возможности отменить git clean -f -d , с помощью которого был удален файл, созданный в eclipse ,

Вы можете сделать то же самое из UI, используя «restore from local history» для ref: Restore from local history

Поделиться


Abdul Rahman K    

28 августа 2015 в 09:31


2

Государства, переходящие от одного коммита к новому коммиту

0. last commit,i.e. HEAD commit
1. Working tree changes, file/directory deletion,adding,modification.
2. The changes are staged in index
3. Staged changes are committed

Действие для перехода в состояние

0->1: manual file/directory operation
1->2: git add .
2->3: git commit -m "xxx"

Проверка diff

0->1: git diff
0->2: git diff --cached
0->1, and 0->2: git diff HEAD
last last commit->last commit: git diff HEAD^ HEAD

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

2->1: git reset
1->0: git checkout .     #only for tracked files/directories(actions include modifying/deleting tracked files/directories)
1->0: git clean -fdx     #only for untracked files/directories(action includes adding new files/directories)
2->1, and 1->0: git reset --hard HEAD

Эквивалент git clone, без повторной загрузки чего-либо

git reset; git checkout .; git clean -fdx

Поделиться


Zii    

01 июля 2016 в 08:54

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

Делает ли git stash stash все изменения или только незафиксированные

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

SourceTree рассматривает извлеченные файлы как незафиксированные изменения

В некоторых неизвестных случаях, когда я вытаскиваю с помощью SourceTree, он рассматривает все вытащенные файлы как незафиксированные изменения и не позволит больше вытаскивать/толкать, если не…

Как отменить git —abort

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

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

Что такое команда p4 , чтобы выбросить все мои незафиксированные изменения в моей рабочей области Perforce? При использовании Git аналогичная команда выглядит следующим образом: git reset —hard

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

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

Отменить одним файлом местных незафиксированные изменения в эгит (например, svn вернуться)

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

Переместить коммиты ветвей в текущий каталог как незафиксированные изменения в рабочем каталоге?

Допустим, что я работаю над branchA , и мне нужно временно зафиксировать все незафиксированные изменения. Так что я создаю branchB и все фиксирую. Через некоторое время мне нужно переместить все эти…

Сделать git пуш плохо, когда есть несохраненные изменения

Обычно я использую что-то вроде следующего, чтобы проверить мои изменения, и если они в порядке, отправьте их в удаленный репозиторий: mvn install && git push Отлично работает, за…

Git — переключение ветвей все незафиксированные изменения исчезли

Я сделал так много изменений в стольких файлах в моем локальном РЕПО git. Но когда я переключил ветку с помощью mac Git-Client без фиксации изменений, появилось окно предупреждения о том, что есть…

Как вернуть мои незафиксированные изменения после git rebase?

У меня были некоторые незафиксированные изменения на моем локальном компьютере,и я хотел отправить запрос на вытягивание. Я сделал git pull —rebase и забыл совершить свои локальные изменения. git…

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

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

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

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

Выполните:

git revert HEAD

Команда revert означает возврат состояния к HEAD – последнему коммиту в ветке.

Появится следующее сообщение:

Если открытие редактора не нужно, к исходной команде добавляется --no-edit. Смотрим, как это работает:

git revert HEAD --no-edit

Чтобы удостовериться, что все сделано правильно, выполняется:

git log

Предыдущий неправильный коммит будет присутствовать в логах, но также вы увидите его удаление:

Проверьте Git-статус следующей командой:

git status

Если нужно откатиться к конкретному коммиту, вместо HEAD вписывается его хеш или тег (можно посмотреть в логах/истории). Иногда такая отмена невозможна из-за конфликтов, то есть произошли изменения, которые Git не может отменить. Увидеть конфликтный файл для дальнейшего решения проблемы поможет git status.

Как видите, revert оставляет «следы» в истории ветки, а иногда нужно подобную ошибку скрыть. К возможностям reset относятся:

  1. Переписывание текущей ветки, которая будет указывать на необходимый коммит.
  2. Сброс буферной зоны (опционально).
  3. Сброс рабочего каталога (опционально).

Для начала отметьте нужную ветку:

git tag oops

Теперь выполните сброс до коммита oops:

git reset --hard t1

Посмотрите историю:

git hist

Однако все равно ничто не теряется. Запустите команду отображения всех коммитов:

git hist --all

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

Различные способы удаления локальных изменений Git — git

Причина добавления ответа в данный момент :

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

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

В основном для очистки всех локальных коммитов
$ git reset --hard и
$ git clean -d -f

Первым шагом перед выполнением коммитов является настройка вашего имени пользователя и email, которое появляется вместе с вашим коммитом.

#Sets имя, которое вы хотите прикрепить к вашим транзакциям фиксации

$ git config --global user.name "[name]"

#Sets тот email, который вы хотите получить в момент совершения транзакции

$ git config --global user.email "[email address]"

#List глобальная конфигурация

$ git config --list

#List пульт дистанционного управления URL

$ git remote show origin

#check статус

git status

#List все локальные и удаленные филиалы

git branch -a

#create создать новую локальную ветвь и начать работать над этой ветвью

git checkout -b "branchname"

или же это может быть сделано в виде двухэтапного процесса

создать ветку: git branch branchname
работа над этой веткой: git checkout branchname

#commit локальные изменения [двухэтапный процесс: — добавление файла в индекс, что означает добавление в промежуточную область. Затем зафиксируйте файлы, которые присутствуют в этой промежуточной области]

git add <path to file>

git commit -m "commit message"

#checkout какой-то другой местный филиал

git checkout "local branch name"

#remove все изменения в локальной ветке [предположим, что вы внесли некоторые изменения в локальной ветке, например, добавили новый файл или изменили существующий файл, или сделали локальную фиксацию, но это больше не нужно]
git clean -d -f и git reset --hard [очистить все локальные изменения, внесенные в локальную ветвь, за исключением локальной фиксации]

git stash -u также удаляет все изменения

Примечание:
ясно, что мы можем использовать либо
(1) комбинация git clean –d –f и git reset --hard
OR
(2) git stash -u
для достижения желаемого результата.

Примечание 1: тайник, так как это слово означает » хранить (что-то) безопасно и тайно в определенном месте.- Это всегда можно восстановить с помощью git stash pop. Так что выбор между двумя вышеперечисленными вариантами-это вызов разработчика.

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

# Переключитесь на главную ветвь и убедитесь, что вы в курсе событий.

git checkout master

git fetch [это может быть необходимо (в зависимости от конфигурации git) для получения обновлений на origin / master ]

git pull

# Объединить ветвь объекта в главную ветвь.

git merge feature_branch

# Сброс главной ветви в исходное состояние.

git reset origin/master

#Accidentally удалил файл из локального, как его восстановить обратно?
Выполните команду git status , чтобы получить полный путь к файлу удаленного ресурса

git checkout branchname <file path name>

вот и все!

#Merge главная ветвь с каким-то другим почерком

git checkout master
git merge someotherbranchname

Местное отделение #rename

git branch -m old-branch-name new-branch-name

#delete местного отделения

git branch -D branch-name

Удаленную ветку #delete

git push origin --delete branchname

или

git push origin :branch-name

#revert фиксация уже отправлена в удаленный репозиторий

git revert hgytyz4567

#branch из предыдущей фиксации с использованием GIT

git branch branchname <sha1-of-commit>

#Change сообщение о фиксации самой последней фиксации, которая уже была удалена

git commit --amend -m "new commit message"
git push --force origin <branch-name>

# Удаление всех локальных коммитов в этой ветке [удаление локальных коммитов]

Чтобы отбросить все локальные коммиты на этой ветке, чтобы сделать локальную ветвь идентичной «upstream» этой ветви, просто запустите

git reset --hard @{u}

Ссылка: http://sethrobertson.github.io/GitFixUm/fixup.html
или do git reset --hard origin/master [если локальная ветвь является главной]

# Отменить фиксацию, уже отправленную в удаленный репозиторий?

$ git revert ab12cd15

#Delete предыдущей фиксации от местных филиалов и удаленных филиалов

Пример использования: вы только что внесли изменения в свою локальную ветвь и сразу же перешли в удаленную ветвь, внезапно осознав, О нет! Мне не нужны эти перемены. А теперь что делать?

git reset --hard HEAD~1 [для удаления этой фиксации из локальной ветви. 1 обозначает сделанный вами коммит ONE]

git push origin HEAD --force [обе команды должны быть выполнены. Для удаления из удаленной ветки]. В настоящее время извлеченная ветвь будет называться ветвью, в которой вы производите эту операцию.

#Delete некоторые из недавних коммитов из локального и удаленного РЕПО и сохранения в нужный вам коммит. ( своего рода возврат коммитов из локального и удаленного)

Предположим, у вас есть 3 коммита, которые вы отправили в удаленную ветку с именем ‘ develop ‘

commitid-1 done at 9am
commitid-2 done at 10am
commitid-3 done at 11am. // latest commit. HEAD is current here.

Вернуться к старой фиксации (изменить состояние ветви)

git log --oneline --decorate --graph // чтобы увидеть все ваши коммиты

git clean -d -f / / очистите все локальные изменения

git reset --hard commitid-1 / / локально возвращаясь к этому commitid

git push -u origin +develop / / переместите это состояние в удаленное. + делать силовой толчок

# Удалить локальное слияние git:
Case:
Я нахожусь на главной ветви и слил главную ветвь с новой рабочей ветвью phase2

$ git status

На ветке мастер

$ git merge phase2
$ git status

На ветке мастер

Ваша ветка опережает ‘origin/master’ на 8 коммитов.

Вопрос: Как избавиться от этого локального слияния git? Попробовал git reset --hard и git clean -d -f -оба не сработали.
Единственное, что сработало , — это любой из нижеперечисленных:

$ git reset —hard origin / master

или

$ git сброс —жесткий HEAD~8

или

$ git reset --hard 9a88396f51e2a068bb7 [sha commit code — это тот, который присутствовал до того, как все ваши коммиты слияния произошли]

#create файл gitignore

touch .gitignore / / создать файл в mac или unix пользователей

образец .gitignore содержание:

.project
*.py
.settings

Ссылка на шпаргалку GIT: https://services.github.com/on-demand/downloads/github-git-cheat-sheet.pdf

Отменить слияние Git, которое еще не было запущено — git

В своей ветви master я сделал git merge some-other-branch локально, но никогда не продвигал изменения в origin master. Я не собиралась сливаться, поэтому хотела бы все исправить. Когда я делал git status после слияния, я получал это сообщение:

# On branch master
# Your branch is ahead of 'origin/master' by 4 commits.

Основываясь на некоторых инструкциях, которые я нашел , я попытался бежать

git revert HEAD -m 1

но теперь я получаю это сообщение с git status :

# On branch master
# Your branch is ahead of 'origin/master' by 5 commits.

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

git

undo

git-merge

Поделиться

Источник


Matt Huggins    

05 марта 2010 в 19:24

25 Ответов


3823

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

git reset --hard commit_sha

Есть и другой способ:

git reset --hard HEAD~1

Это вернет вам 1 коммит.

Имейте в виду, что любые измененные и незафиксированные/неэкранированные файлы будут сброшены в их неизмененное состояние . Чтобы сохранить их, либо прячьте изменения, либо смотрите опцию --merge ниже.

Как @Velmont предложил ниже в своем ответе, в этом прямом случае используя:

git reset --hard ORIG_HEAD

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

Еще один совет-использовать переключатель --merge вместо --hard , так как он не сбрасывает файлы без необходимости:

git reset --merge ORIG_HEAD

—поглощать

Сбрасывает индекс и обновляет файлы в рабочем дереве, которые отличаются между <commit> и HEAD, но сохраняет те, которые отличаются между индексом и рабочим деревом (т. е. которые имеют изменения, которые не были добавлены).

Поделиться


Marcin Gil    

05 марта 2010 в 19:34


1356

Предполагая, что ваш местный мастер не опередил origin/master,, вы должны быть в состоянии сделать это

git reset --hard origin/master

Тогда ваша локальная ветвь master должна выглядеть идентично origin/master .

Поделиться


randomguy3    

17 марта 2011 в 18:06

Поделиться


Yuri Geinish    

02 июня 2011 в 16:31


924

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

git reset --merge ORIG_HEAD

Ref ORIG_HEAD будет указывать на исходную фиксацию до слияния.

(Параметр --merge не имеет никакого отношения к слиянию. Это так же , как git reset --hard ORIG_HEAD, но безопаснее, так как он не касается незафиксированных изменений.)

Поделиться


odinho — Velmont    

29 января 2013 в 15:46


349

С более новыми версиями Git, если вы еще не зафиксировали слияние и у вас есть конфликт слияния , вы можете просто сделать это:

git merge --abort

От man git merge :

[This] можно запустить только после того, как слияние привело к конфликтам. git merge --abort прервет процесс слияния и попытается восстановить состояние перед слиянием.

Поделиться


Travis Reeder    

12 февраля 2013 в 02:13


119

Вы должны вернуться к предыдущей фиксации. Это должно сработать:

git reset --hard HEAD^

Или даже HEAD^^ , чтобы отменить этот обратный фиксат. Вы всегда можете дать полную ссылку на SHA, если не уверены, сколько шагов назад вы должны сделать.

В случае, если у вас возникли проблемы и ваша главная ветвь не имела локальных изменений, вы можете сбросить значение origin/master .

Поделиться


MBO    

05 марта 2010 в 19:31


81

В последнее время я использую git reflog , чтобы помочь с этим. Это в основном работает только в том случае, если слияние JUST произошло, и оно было на вашей машине.

git reflog может вернуть что-то вроде:

fbb0c0f HEAD@{0}: commit (merge): Merge branch 'master' into my-branch
43b6032 HEAD@{1}: checkout: moving from master to my-branch
e3753a7 HEAD@{2}: rebase finished: returning to refs/heads/master
e3753a7 HEAD@{3}: pull --rebase: checkout e3753a71d92b032034dcb299d2df2edc09b5830e
b41ea52 HEAD@{4}: reset: moving to HEAD^
8400a0f HEAD@{5}: rebase: aborting

Первая строка указывает на то, что произошло слияние. 2-я строка — это время до моего слияния. Я просто git reset --hard 43b6032 , чтобы заставить эту ветку отслеживать до слияния,и продолжить.

Поделиться


Parris    

19 декабря 2014 в 17:51


47

С современной Git, вы можете:

git merge --abort

Старый синтаксис:

git reset --merge

Старая школа:

git reset --hard

Но на самом деле, стоит заметить, что git merge --abort эквивалентно только git reset --merge , учитывая, что MERGE_HEAD присутствует. Об этом можно прочесть в Git помощи команды merge.

git merge --abort is equivalent to git reset --merge when MERGE_HEAD is present.

После неудачного слияния, когда нет MERGE_HEAD, неудачное слияние может быть отменено с git reset --merge , но не обязательно с git merge --abort, поэтому они не являются только старым и новым синтаксисом для одной и той же вещи .

Лично я нахожу git reset --merge гораздо более мощным и полезным в повседневной работе, так что это тот, который я всегда использую.

Поделиться


Martin G    

08 мая 2015 в 19:13


36

Ладно, ответы других людей здесь были близки, но это не сработало. Вот что я сделал.

Делающий это…

git reset --hard HEAD^
git status

…

дал мне следующий статус.

# On branch master
# Your branch and 'origin/master' have diverged,
# and have 3 and 3 different commit(s) each, respectively.

Затем мне пришлось ввести одну и ту же команду git reset еще несколько раз. Каждый раз, когда я это делал, сообщение менялось на одно, как вы можете видеть ниже.

> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch and 'origin/master' have diverged,
# and have 3 and 3 different commit(s) each, respectively.
> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch and 'origin/master' have diverged,
# and have 2 and 3 different commit(s) each, respectively.
> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch and 'origin/master' have diverged,
# and have 1 and 3 different commit(s) each, respectively.
> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch is behind 'origin/master' by 3 commits, and can be fast-forwarded.

В этот момент я увидел, что сообщение о состоянии изменилось, поэтому я попытался сделать git pull , и это, похоже, сработало:

> git pull
Updating 2df6af4..12bbd2f
Fast forward
 app/views/truncated |    9 ++++++---
 app/views/truncated |   13 +++++++++++++
 app/views/truncated |    2 +-
 3 files changed, 20 insertions(+), 4 deletions(-)
> git status
# On branch master

Короче говоря, мои приказы сводились к этому:

git reset --hard HEAD^
git reset --hard HEAD^
git reset --hard HEAD^
git reset --hard HEAD^
git pull

Поделиться


Matt Huggins    

05 марта 2010 в 19:54


21

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

Конкретно,

$ git reflog
$ git reset --hard HEAD@{0}

Поделиться


stephjang    

17 января 2014 в 22:36


13

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

$ git checkout -f

Это отменит слияние (и все, что вы сделали).

Поделиться


Idealmind    

18 января 2013 в 15:25


13

Добрался до этого вопроса также глядя, чтобы вернуться к соответствию origin (то есть, NO совершает перед origin). Исследуя дальше, обнаружил, что есть команда reset именно для этого:

git reset --hard @{u}

Примечание: @{u} -это сокращение от origin/master . (И, конечно же, вам нужен этот удаленный репозиторий, чтобы это работало.)

Поделиться


leanne    

16 февраля 2017 в 21:54


11

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

git reset --hard remotes/origin/HEAD

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

Поделиться


Ralph Ritoch    

25 июля 2018 в 09:55


10

Просто для дополнительной опции, чтобы посмотреть, я в основном следовал модели ветвления, описанной здесь: http://nvie.com/posts/a-successful-git-branching-model/ и как таковой обычно сливался с --no-ff (без быстрой перемотки вперед).

Я только что прочитал эту страницу, поскольку случайно слил тестовую ветвь вместо моей ветви выпуска с master для развертывания (website, master — это то, что работает). Тестовая ветвь имеет две другие ветви, объединенные в нее, и составляет около шести коммитов.

Поэтому, чтобы отменить весь коммит, мне просто нужен был один git reset --hard HEAD^ , и он вернул все слияние. Поскольку слияния не были быстро переадресованы, слияние было блоком, и один шаг назад — это «branch not merged».

Поделиться


Damien Byrne    

09 июня 2011 в 00:54


10

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

  1. git reset --hard commitHash (вы должны использовать фиксацию, которую хотите перезапустить, например. 44a587491e32eafa1638aca7738)
  2. git push origin HEAD --force (отправка новой локальной главной ветви в origin/master)

Удачи вам и вперед!

Поделиться


Matheus Abreu    

12 декабря 2014 в 23:16


10

Самый простой ответ дает одиньо-Вельмонт

Сначала сделай git reset --merge ORIG_HEAD

Для тех, кто хочет сбросить настройки после внесения изменений, сделайте это
(Потому что это первый пост, увиденный для любых вопросов git reset merge)

git push origin HEAD --force

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

Поделиться


Harsha    

02 ноября 2017 в 23:22


10

Если вы находитесь в середине слияния вы всегда можете прервать его
git merge --abort

Поделиться


llioor    

13 декабря 2018 в 14:05


7

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

Например, я случайно слил ветку Development в master и хотел ее отменить. Используя следующие шаги:

git checkout develop
git branch -D master
git branch -t master origin/master

Вуаля! Мастер находится на той же стадии, что и источник, и Ваше неверно слитое состояние стирается.

Поделиться


Stephan    

26 июня 2012 в 11:15


4

Если вам нужно решение командной строки, я предлагаю просто пойти с ответом MBO.

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

  1. Kick off gitk (из командной строки или щелкните правой кнопкой мыши в браузере файлов, если у вас есть это)
  2. Вы можете легко обнаружить коммит слияния там — первый узел сверху с двумя родителями
  3. Перейдите по ссылке на первый / левый родитель (тот, который находится в вашей текущей ветви перед слиянием, обычно красный для меня)
  4. На выбранной фиксации щелкните правой кнопкой мыши «сбросить ветку сюда», выберите жесткий сброс там

Поделиться


inger    

21 марта 2013 в 14:38


4

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

Обоснование: возврат к слиянию-это сложно. Существует слишком много решений, зависящих от многих факторов, таких как фиксация или принудительное слияние, а также наличие новых фиксаций после слияния. Кроме того, вам все еще нужно иметь относительно глубокое понимание git, чтобы адаптировать эти решения к вашему случаю. Если вы слепо следуете некоторым инструкциям, вы можете получить «empty merge», где ничего не будет объединено, и дальнейшие попытки слияния заставят Git сказать вам «Already up to date».

Решение:

Допустим, вы хотите объединить dev в feature-1 .

  1. Найдите ревизию, которую вы хотите получить слиянием:

    git log --oneline feature-1
a1b2c3d4 Merge branch 'dev' into 'feature-1' <-- the merge you want to undo
e5f6g7h8 Fix NPE in the Zero Point Module <-- the one before the merge, you probably want this one

  2. Проверьте это (вернуться назад во времени):

    git checkout e5f6g7h8

  3. Создайте оттуда новую ветку и проверьте ее:

    git checkout -b feature-1

Теперь вы можете перезапустить слияние:

  1. Слияние: git merge dev

  2. Исправьте конфликты слияния.

  3. Фиксация: git commit

  4. Когда вы будете удовлетворены результатами, удалите старую ветку: git branch --delete feature-1

Поделиться


pyb    

11 июня 2015 в 15:42


1

Я думаю, что вы можете сделать git rebase -i [hash] [branch_name] , где [hash] -это идентификация hash для того, как далеко назад вы хотите перемотать плюс один (или сколько коммитов назад вы хотите пойти), а затем удалить строки для коммитов в Редакторе, которые вам больше не нужны. Сохранить файл. Выход. Молиться. И он должен быть перемотан назад. Возможно , вам придется сделать git reset --hard, но на данный момент это должно быть хорошо. Вы также можете использовать это для извлечения определенных коммитов из стека, если вы не хотите хранить их в своей истории, но это может оставить ваш репозиторий в состоянии, которое вам, вероятно, не нужно.

Поделиться


tychoish    

08 марта 2010 в 02:55


1

  1. Во-первых, убедитесь, что вы все сделали правильно.

  2. Затем сбросьте хранилище в предыдущее рабочее состояние:

    $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36

    или с помощью --hard ( это удалит все локальные, не зафиксированные изменения! ):

    $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36 --hard

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

  3. Проверьте, какие коммиты вы хотите повторно зафиксировать в верхней части предыдущей правильной версии, выполнив следующие действия::

    $ git log 4c3e23f529b581c3cbe95350e84e66e3cb05704f

commit 4c3e23f529b581c3cbe95350e84e66e3cb05704f

...

commit 16b373a96b0a353f7454b141f7aa6f548c979d0a

...

  4. Примените ваши правые фиксации в верхней части правой версии вашего репозитория, используя:

    • С помощью cherry-pick (изменения, внесенные некоторыми существующими коммитами)

          git cherry-pick ec59ab844cf504e462f011c8cc7e5667ebb2e9c7

    • Или вишня-выбор диапазона фиксации:

      • Сначала проверьте правильные изменения перед их объединением:

        git diff 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f

      • Сначала проверьте правильные изменения перед их объединением:

        git cherry-pick 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f

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

Поделиться


kenorb    

29 января 2013 в 15:09


1

Если вы совершили слияние:

git reset HEAD~1
# Make sure what you are reverting is in fact the merge files
git add .
git reset --hard

Поделиться


Dorian    

10 ноября 2016 в 15:57


0

Самый простой из самых простых шансов, гораздо проще, чем все сказанное здесь:

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

Поделиться


Luis    

15 июля 2016 в 14:16


0

Если вы заметили, что вам нужно вернуться сразу после слияния, и вы больше ничего не сделали после попытки слияния, вы можете просто выполнить эту команду:
git reset --hard HEAD@{1} .

По сути, ваше слияние sha будет указывать на HEAD@{0} , если ничего больше не было зафиксировано после слияния, и поэтому HEAD@{1} будет предыдущей точкой перед слиянием.

Поделиться


Dut A.    

26 апреля 2016 в 18:52

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

Git удалить удаленное слияние и ветвление

Я работаю над своей веткой разработки. Я проверил ветку ‘branch-xxx’, зафиксировал свои изменения, а затем объединил ветку в Developer, только чтобы узнать, что этот кусок кода глючит! Как я могу…

Git отменить автоматическое слияние только для определенного файла, а не для всей ветви

Есть ли способ отменить автоматическое слияние одного файла, который был изменен вместо всей ветви в Git? Я хочу отменить это слияние: Автоматическое слияние public/stylesheets/application.css к…

Отменить фиксацию от мастера, используя запросы (защищенный мастер)

Можно ли вернуть фиксацию слияния на master из ветви функции, которая уже была перемещена на удаленный сервер? E.g. создать ветвь объекта из фиксации слияния в master, отменить фиксацию и объединить…

Как сделать Git честь отмененного слияния, которое не было запрошено?

Я уже сталкивался с этой ситуацией примерно 3 или 4 раза. Иногда Git захочет выполнить слияние. Это происходит в ответ на git commit <filename> -m <message> , за которым следует git push…

Как отменить слияние, которое было сделано до моего последнего коммита?

Длинная история короче: Я слился воедино Я ввел новые изменения. Я хочу отменить слияние, но сохранить новые изменения. Я знаю, что git reset —hard <hash> отменит фиксацию, и если я сделаю…

Bigquery отменяет или останавливает задание пакетного запроса, которое еще не запущено (Status.State = «PENDING»)

Если по какой-то причине требуется остановить/отменить задание пакетного запроса, которое еще не запущено (Status.State = PENDING), возможно ли это сделать? (используемая библиотека: net…

Как отменить слияние на Bitbucket?

Я создал слияние (в ветку ‘master’), которое теперь находится в репо Bitbucket. Короче говоря, мне нужно отменить это слияние. Я знаю, что вы можете сделать это на самом сайте Github, но Bitbucket…

Отменить слияние git, когда оно было выдвинуто

Как я могу отменить слияние, когда я уже нажал на мастер после слияния? Вот мои шаги: git add -A git commit -m some message git fetch origin master:master git rebase master (resolve merge conflicts)…

Отменить слияние в git и восстановить состояние с помощью rebase

Допустим, у меня есть этот график: A — B — C1.1 — D — E — F -G (master) \_ C2.1 _/(feature) И я хочу отменить слияние, добавить что-то вроде C1.2 в главную ветвь,а затем повторно объединить и…

Отменить git автоматическое слияние

После переключения ветвей я применил stash (как показано ниже), что привело к автоматическому слиянию.  git stash apply Auto-merging src/clojure/project_src.clj On branch upgrade_project Changes…

Многочисленные возможности отмены в Git

GitLab Документы