Как решить конфликты git
Git для начинающих. Урок 10.
Конфликты и их разрешение
Видеоурок
Конспект урока
Краткое содержание урока, основные инструкции для командной строки, полезные ссылки и советы.
Работа с конфликтами в командной строке
До этого момента мы или работали в одиночку, или с коллегой над разными участками кода. То есть не пересекались с другими программистами. На практике такое бывает редко, и случается, что приходится править те же участки кода, что и наши коллеги.
Посмотрим на практике
У нас есть блок учеников, он уже в мастере и выглядит так
Нам нужно доработать этот блок, мы создаем новую ветку students-redesign и изменяем этот блок. Мы хотим добавить классы к тегам ul и li. Получается так
Закоммитим эти изменения и будем готовы залить в мастер. Но пока мы работали, нашему коллеге поручили добавить в этот же блок нового ученика. Эту задачу коллега уже сделал и залил в мастер. У него (и в мастере) код блока учеников теперь выглядит так
То есть просто добавил еще один тег li. Конечно, наших изменений он не видел.
Таким образом два человека правили код в одном и том же месте.
Мы переключаемся в мастер, пулимся, подтягиваем его коммит и пытаемся слить ее в мастер. И видим такое
Здесь git говорит, что обнаружен конфликт. То есть в текущей ветки (master) и в той, которую мы пытаемся вмерджить (students-redesign) есть изменения в одних и тех же участках кода. Нужно посмотреть, в чем заключается конфликт. Открываем файл index.html и видим
Как работать с конфликтами в PhpStorm
Такое визуальное разделение гораздо проще, чем анализировать сплошной текст с угловыми скобками и разделителями ===
Когда мы разрешим все конфликты, PhpStorm предложит нам нажать кнопку Apply, чтобы закончить мердж. Мы ее нажмем и IDE создаст мердж-коммит без необходимости коммитить вручную, как мы это делали в командной строке.
Мердж мастера в свою ветку
Происходит точно так же, как и нашей ветки в мастер. Конфликты резолвим аналогично. При этом когда придет время сливать ветку в мастер, разрешать конфликты больше не придется, потому что мы уже создали коммит с фиксом конфликта.
Для информации
Когда я начинал изучать git, конфликты для меня были самой большой проблемой. Каждый раз, когда мерджил ветку в мастер, я со страхом ждал, будет конфликт или нет. Реакция была примерно такая
Что могу посоветовать
На этом первая часть курса закончена
Спасибо за внимание и до встречи!
Разрешение конфликтов слияния
Azure Repos | Azure DevOps Server 2020 | Azure DevOps Server 2019 | TFS 2018-TFS 2015
Visual Studio 2019 | Visual Studio 2017 | Visual Studio 2015
При объединении одной ветви в другую изменения файла из фиксаций в одной ветви могут конфликтовать с изменениями в другой. Git пытается разрешить эти изменения с помощью журнала в репозитории, чтобы определить, как должны выглядеть объединенные файлы. Если не ясно, как объединять изменения, Git останавливает слияние и сообщает, какие файлы конфликтуют.
Из этого руководства вы узнаете, как выполнить следующие задачи:
Общие сведения о конфликтах слияния
На следующем рисунке показан самый простой пример конфликта изменений в Git. Обе ветви Main и бугфикс обновляют одни и те же строки исходного кода.
Если вы попытаетесь объединить ветвь бугфикс в Main, Git не сможет определить, какие изменения следует использовать в объединенной версии. Вам может потребоваться внести изменения в главную ветвь, ветвь бугфикс или некоторое сочетание этих двух параметров. Устраните этот конфликт с фиксацией слияния в основной ветви, которая согласовывает конфликтующие изменения между двумя ветвями.
Наиболее распространенной ситуацией конфликта слияния является случай, когда вы извлекаете обновления из удаленной ветви в локальную ветвь, например из origin/bugfix в локальную bugfix ветвь. Разрешите эти конфликты аналогичным образом — создайте фиксацию слияния в локальной ветви, чтобы согласовать изменения и завершить слияние.
Что делает Git для предотвращения конфликтов слияния?
Git хранит весь журнал всех изменений, внесенных в репозиторий. Git использует этот журнал, а также отношения между фиксациями, чтобы определить, может ли он упорядочить изменения и автоматически разрешить слияние. Конфликты возникают, только если не ясно, как изменения в одних и тех же строках в одних и тех же файлах должны быть объединены.
Предотвращение конфликтов слияния
Разрешение конфликтов слияния
Если вы используете Visual Studio 2019 версии 16.8 или выше, опробуйте систему управления версиями Git. Узнайте, чем интерфейс Git отличается от Team Explorer, на странице наглядного сравнения.
Вы будете уведомлены о конфликтах слияния при вытягивание изменений или попытке объединить две ветви.
Появится уведомление о конфликте. Щелкните ссылку » конфликты «, чтобы начать устранение конфликтов файлов.
Будет приведен список файлов с конфликтами. Выбор файла позволяет принять изменения в исходной ветви, из которой выполняется слияние, с помощью кнопки взять источник или принять изменения в ветви, в которую выполняется слияние, с помощью команды » оставить цель«. Можно выполнить слияние изменений вручную, выбрав объединить, а затем введя изменения непосредственно в средство слияния, указанное в параметрах Git.
Используйте флажки рядом со строками, измененными для выбора между удаленными и локальными изменениями, или измените результаты непосредственно в редакторе результатов в исходном и целевом редакторе в представлении diff.
Откройте представление изменения в Team Explorer и зафиксируйте изменения, чтобы создать фиксацию слияния и разрешить конфликт.
сравните конфликтующие фиксации, а также различия между общим журналом с параметрами в средстве слияния Visual Studio.
Разрешение конфликтов слияния в командной строке:
Раздел является изменениями из одной фиксации, ======= отделяет изменения и >>>>>>> для другой конфликтующей фиксации.
Измените файлы так, чтобы они точно проглядели, как они должны удалять маркеры. Используйте git add для размещения разрешенных изменений.
Разрешение конфликтов при удалении файлов с помощью git add (сохранения файла) или git rm (удаление файла).
Безболезненное разрешение Merge конфликтов в Git
Предлагаю читателям «Хабрахабра» перевод публикации «Painless Merge Conflict Resolution in Git»
из блога blog.wuwon.id.au.
В моей повседневной работе, часто приходится иметь дело со множеством git ветвей (branch). Это могут быть ветви промежуточных релизов, ветви с устаревшим API находящиеся на поддержке для некоторых клиентов, или ветви с экспериментальными свойствами. Лёгкость создания ветвей в модели Git так и соблазняет разработчиков создавать все больше и больше ветвей, и как правило бремя от большого количества ветвей становится очень ощутимым, когда приходится все эти ветви поддерживать и периодически делать слияния (merge) с другими ветвями.
Слияния очень важны для поддержания кода в актуальном состоянии, и как правило ошибка сделанная при слиянии может привести к большей головной боли, нежели ошибка сделанная при простом коммите. К сожалению ошибки слияния далеко не редкость, потому что во-первых слияния имеют несколько родительских ветвей. Даже при анализе истории слияния ветвей, бывает очень трудно понять, какие же изменения были сделаны для разрешения конфликта. Во-вторых, отмена неудачного слияния может превратиться в большую головную боль. В-третьих, большая часть конфликтов слияния происходит при работе с чужим кодом, потому что само понятие ветвей подразумевает множество пользователей, т.е. далеко не всегда слияние производит тот же человек который работал с той или иной веткой. В сухом остатке, сделать ошибку при слиянии очень легко, её трудно исправить и трудно найти. Таким образом время потраченное на изучение и понимание процесса слияния ветвей, окупится с лихвой.
Удивительно, но я обнаружил, что многие доступные инструменты и интерфейсы предназначенные для выполнения слияний, не достаточно хорошо оснащены для эффективного выполнения этого процесса. Часто программист просто надеется что команда git merge сделает за него всю работу. Но когда все-таки происходит конфликт, то обычно стратегия слияния заключается в беглом просмотре кода вокруг строки конфликта, и интуитивном угадывании что именно данный кусок кода предпочтительней другого.
В данной статье я надеюсь продемонстрировать что процесс разрешения конфликтов может быть пошагово точным, при котором отпадает необходимость что-либо там угадывать.
Голубые Розы (Roses are Blue)
Давайте предположим что вашей команде поручили писать поэмы в отведённом для этих целей репозитории. (Какой кошмар!) А вам доверили самое главное — делать слияния последних фиксов из ветки master в ветку beta. Итак, вы переключаетесь в ветку beta и выполняете следующую команду:
Ого, это конфликт. Вы решаете просмотреть файл на который ссылается git:
Замечательно! Весь файл, как показывает Listing 1, находится в конфликтном состоянии. Какой же вариант файла является более корректным? Оба варианта выглядят корректно. Верхний вариант написан в хакер-стиле с элементами цветовой кодировки в стиле HTML и с использованием только строчных букв. Нижний вариант выглядит более натурально, с использованием пунктуации и заглавных букв.
Если бы это был ваш проект, вы бы могли просто выбрать один вариант и покончить с этим слиянием. Но проблема в том, что это не ваша поэма, вы никогда не читали эту поэму раньше, не были ответственны за написание или редактирование, и вы отлично понимаете что в случае не верного решения чья-то тяжёлая работа может кануть в небытие. Однако вас всё же назначили ответственным по слиянию этих веток. Что же вам делать?
Назад к Базе (Back to Base)
Хитрость заключается в том, что Listing 1 не даёт вам полную информацию, необходимую для совершения корректного слияния. На самом деле, в процессе слияния участвуют четыре важных части информации (состояния), три из которых просто необходимы для успешного разрешения конфликта. В случае Listing 1, Git предоставил вам только два состояния.
Следующая диаграмма иллюстрирует эти четыре состояния:
Состояния (B) и © относятся к текущим положениям (head) веток master и beta соответственно, эти два состояния как раз таки и отражены в Listing 1. Состояние (D) это результат слияния, то что вы хотите получить/сгенерировать в конечном итоге (в большинстве случаев Git автоматически генерирует состояние (D)). Состояние (А) на самом верху, представляет собой базу (основу) слияния веток master и beta. База слияния (A) это последний общий предок веток master и beta, и пока предположим что это база слияния уникальна. Как мы увидим позже состояние (A) играет ключевую роль в разрешении конфликтов. На диаграмме я также отразил дельты 1 и 2, которые представляют изменения между состояниями (A)-(B), и (A)-© соответственно. Зная состояния (A), (B) и © дельты 1 и 2 могут быть легко получены (вычислены). Обратите внимание, что дельты 1 и 2 могут состоять из более чем одного коммита. Но для наших целей будем считать что все дельты монолитны.
Чтобы понять, как получить состояние (D), вы должны понимать что же операция слияния пытается сделать. Состояние (D) должно представлять собой сочетание изменений, внесённых в ветку master и beta соответственно. Т.е. другими словами сочетание дельт 1 и 2. Идея проста на поверхности и большую часть времени не требует вмешательства со стороны человека, за исключением особых случаев когда дельты затрагивают наслаиваемые (пересекающиеся) части файла. В такой ситуации вам требуется помочь машине сгенерировать результат (D), путём сравнения дельт 1 и 2.
Определение Отличий (Identifying the Differences)
Для того чтобы найти изменения внесённые в каждую ветку, необходимо знать как выглядит база слияния, состояние (A). Самый простой механизм получения информации о базе слияния, это установка опции merge.conflictstyle в значение diff3
Теперь мы видим третий фрагмент посередине, который и является базой слияния или состояние (A). Изменения видны как на ладони: в ветке beta (HEAD) человеческие названия цветов были заменены на HTML коды, а в ветку master добавили капитализацию и пунктуацию. Основываясь на этих знаниях, мы теперь знаем что результат должен включать в себя капитализацию, пунктуацию и HTML коды цветов.
В принципе на этом можно было бы и закончить, потому что результат достигнут. Но есть решение и получше.
Графическое Слияние (GUI Merging)
Хотя и простое текстовое представление конфликта слияния делает свою работу в простых случаях, на практике конфликты могут быть более радикальными и сложными. В таких случаях могут помочь графические инструменты. Мой выбор пал на простой инструмент написанный на Python под названием meld, но может подойти любой другой графический инструмент, способный представить слияние в трёх-колоночном виде.
Для использования графического инструмента (он должен быть установлен), после того как git пожаловался что есть конфликт, введите следующую команду:
Последует вопрос какой программой для слияния вы хотели бы воспользоваться, просто введите meld и нажмите Enter. Вот как окно программы может выглядеть (подразумевается опция merge.conflictstyle не была включена):
Несмотря на то что информация представлена бок о бок, она не отображает нужные фрагменты которые были в Listing 2. Мы не видим здесь фрагмента базы слияния (состояния (A)), что мы видим это файл roses.txt.LOCAL.2760.txt в левой колонке и файл roses.txt.REMOTE.2760.txt в правой колонке и файл посередине это неудачное слияние. Т.е. по сути нам представили состояния (B), © и несостоявшееся состояние (D), но состояние (A) отсутствует.
Правда отсутствует? Давайте проверим, в старом добром терминале:
Видим интересующий нас файл: roses.txt.BASE.2760.txt. Это и есть файл базы слияния. Теперь нам осталось всего лишь найти изменения внесённые в ветки master и beta, по отношению к базе. Мы можем сделать это двумя отдельными вызовами meld:
(Кто-то может подметить что было бы более разумно, поменять порядок аргументов в первом вызове, для того чтобы файл базы находился в левой колонке в обоих случаях, но именно такой порядок сохраняет подобие трёх-колоночного вида, при котором база остаётся по середине.) Результат выполнения — два окна как показано ниже:
При чтении первого окна справа налево и второго окна слева направо, становится ясно как день, какие изменения произошли в каждой ветке. Так как meld любезно подсветил все изменения, теперь практически не возможно пропустить даже мелко заметные правки (Кто-нибудь заметил добавление предлога «of» при просмотре текстового представления разрешения конфликта Listing 1 или даже Listing 2?)
Вооружившись этими знаниями, мы теперь можем вернуться к трёх-колоночному представлению и сделать изменения. Моя стратегия ручного слияния это взять весь текст из ветки с более весомыми изменениями (в данном случае master/REMOTE т.е. beta), и поверх него производить пошаговые правки, т.е. вносить изменения сделанные в другой ветке (master). Вот что получилось:
А теперь всё вместе (All Together Now)
И добавьте следующее в ваш
Теперь, когда вы в следующий раз будете запускать команду git mergetool для разрешения конфликта, откроются все три окна:
После того как вы привыкните к такому разрешению конфликтов с использованием трёх вышеупомянутых окон, вы скорее всего обнаружите, что процесс стал более методичным и механическим. В большинстве случаев, вам даже не придётся читать и понимать куски кода из каждой ветки, для того чтобы понять какой же вариант применить для слияния. Вам больше не понадобится догадываться, потому что вы будете гораздо более уверенным в корректности вашего комита. Из-за этой уверенности, появится чувство что разрешение конфликтов превратилось в увлекательное занятие.
Бонус от переводчика
Для тех кто пользуется tmux и n?vim, предлагаю следующий скрипт gitmerge:
Примечание: если вы не используете эту опцию в своем
/.tmux.conf, то вам надо поменять в двух последних строках «$sn:1» на «$sn:0»
Соответственно добавьте следующее в ваш
Воркфлоу разрешения конфликта будет выглядеть так:
Пока игнорируем вопрос (Was the merge successful [y/n]?) и переключаемся в сессию под названием gitmerge (сочетание TMUXPREFIX + s):
Видим наше трёх-оконное представление на одном экране. Цифрами обозначены сплиты (panes) tmux’a, буквами соответствующие состояния. Делаем правки для разрешения конфликта, т.е. редактируем состояние (D) и сохраняем. После этого возвращаемся обратно в исходную сессию tmux’a и подтверждаем что слияние произошло успешно.
git rebase master
Лично я предпочитаю и считаю более правильным делать сначала rebase master в ветке beta, и только после этого переключаться в master и делать git merge beta. В принципе воркфлоу не сильно отличается, за исключением трёх-оконного вида.
Переключаемся в сессию gitmerge
Обратите внимание, что состояния (B) и © поменялись местами:
Рекомендую всем поиграться с примером репозитария хотя бы один раз, сделать разрешение конфликта по вышеописанной схеме. Лично я больше не гадаю а что же выбрать «Accept theirs» или «Accept yours».
Как разрешать конфликты слияния в Git
есть ли хороший способ объяснить, как разрешить конфликты слияния в Git?
30 ответов
попробуй: git mergetool
он открывает графический интерфейс, который проходит через каждый конфликт, и вы можете выбрать, как объединить. Иногда это требует немного ручного редактирования после этого, но обычно этого достаточно само по себе. Конечно, это гораздо лучше, чем делать все вручную.
согласно комментарию @JoshGlover:
Ниже приведен пример процедуры, чтобы использовать vimdiff для разрешения конфликтов слияния. На основе этой ссылке
Шаг 1: выполните следующие команды в вашем терминале
это установит vimdiff как слияние по умолчанию инструмент.
Шаг 2: выполните следующую команду в терминале
Шаг 3: вы увидите дисплей vimdiff в следующем формате
LOCAL-это файл из текущей ветви
BASE-общий предок, как файл выглядел до обоих изменений
REMOTE-файл, который вы объединяете в свою ветку
MERGED-merge result, это то, что сохраняется в репо
дополнительная информация о навигации vimdiff здесь и здесь
Шаг 4. Вы можете отредактировать объединенное представление следующим образом
если вы хотите получить изменения от Удаленный
если вы хотите получить изменения от базы
если вы хотите получить изменения от LOCAL
Шаг 5. Сохранить, выйти, совершить и очистить
:wqa сохранить и выйти из Vi
git clean удалить лишние файлы (например *.orig) создано инструментом diff.
вот вероятный вариант использования, сверху:
вы собираетесь тянуть некоторые изменения, но упс, вы не в курсе:
Итак, вы обновляетесь и повторяете попытку, но имеете конфликт:
Итак, вы решили взглянуть на изменения:
о меня, О мой, вверх по течению изменились некоторые вещи, но просто использовать мои изменения. нет. их изменения.
и затем мы попробуем финал время
Я нахожу, что инструменты слияния редко помогают мне понять конфликт или разрешение. Обычно я более успешно смотрю на маркеры конфликтов в текстовом редакторе и использую git log в качестве дополнения.
вот несколько советов:
Совет Один
лучшее, что я нашел, это использовать стиль конфликта слияния» diff3″:
git config merge.conflictstyle diff3
это создает маркеры конфликтов, такие как:
средний раздел Что похож на общего предка. Это полезно, потому что вы можете сравнить его с верхней и нижней версиями, чтобы получить лучшее представление о том, что было изменено на каждой ветке, что дает вам лучшее представление о цели каждого изменения.
если конфликт только несколько строк, это обычно делает конфликт очень очевидным. (Знание того, как исправить конфликт, совсем другое; вы должны знать, над чем работают другие люди. Если вас смущает, лучше просто назвать это человек в вашей комнате, чтобы они могли видеть, на что вы смотрите.)
если конфликт длиннее, то я буду вырезать и вставлять каждый из трех разделов в три отдельных файла, таких как «мой», «общий» и «их».
затем я могу запустить следующие команды, чтобы увидеть два разных куска, которые вызвали конфликт:
это не то же самое, что использовать инструмент слияния, так как инструмент слияния будет включать в себя все неконфликтные куски diff. Я считаю, что отвлекающий.
Совет Два
кто-то уже упоминал об этом, но понимание намерения за каждым отличием обычно очень полезно для понимания, откуда возник конфликт и как с ним справиться.
Это показывает все коммиты, которые коснулись этого файла между общим предком и двумя головами, которые вы объединяете. (Таким образом, он не включает коммиты, которые уже существуют в обеих ветвях до слияния.) Это поможет вам игнорировать diff hunks это явно не является фактором вашего нынешнего конфликта.
Совет Третий
Проверьте изменения с помощью автоматических инструментов.
если у вас есть автоматические тесты, запустите их. Если у вас есть Линта выполните это. Если это сборный проект, создайте его перед фиксацией и т. д. Во всех случаях, вам нужно сделать немного испытания, чтобы убедиться, что ваши изменения ничего не сломали. (Черт, даже слияние без конфликтов может нарушить рабочий код.)
Совет Четыре!—9—>
план вперед; общаться с коллегами.
планирование вперед и осознание того, над чем работают другие, может помочь предотвратить конфликты слияния и/или помочь разрешить их раньше-в то время как детали все еще свежи в памяти.
например, если вы знаете, что вы и другой человек работаете над разными рефакторингами, которые будут влиять на один и тот же набор файлов, вы должны заранее поговорить друг с другом и получить лучшее представление о том, какие типы файлов каждый из вас вносит изменения. Вы можете сэкономить значительное время и усилия, если будете проводить запланированные изменения последовательно, а не параллельно.
для основных рефакторингов, которые пересекают большую полосу кода, Вы должны настоятельно рассмотреть возможность работы последовательно: все перестают работать над этой областью кода, пока один человек выполняет полный рефакторинг.
если вы не можете работать последовательно (из-за давления времени, возможно), то сообщая об ожидаемых конфликтах слияния по крайней мере, поможет вам решить проблемы раньше, пока детали еще свежи в памяти. Например, если сотрудник совершает разрушительную серию коммитов в течение одной недели, вы можете выбрать слияние / ребазирование в этой ветви сотрудников один или два раза в день в течение этой недели. Таким образом, если вы найдете конфликты слияния/перебазирования, вы сможете решить их быстрее, чем если вы подождете несколько недель, чтобы объединить все вместе в один большой кусок.
Совет Пятый
если вы не уверены в слиянии, не форсируйте его.
слияние может показаться подавляющим, особенно когда есть много конфликтующих файлов и маркеры конфликтов охватывают сотни строк. Часто при оценке программных проектов мы не включаем достаточно времени для накладных расходов, таких как обработка узловатого слияния, поэтому кажется, что тратить несколько часов на разбор каждого конфликта-настоящее сопротивление.
в долгосрочной перспективе, планируя вперед и зная о том, что другие работают над лучшие инструменты для прогнозирования конфликтов слияния и подготовки к их правильному разрешению за меньшее время.
определите, какие файлы находятся в конфликте (Git должен сказать вам это).
откройте каждый файл и проверьте различия; Git разграничивает их. Надеюсь, будет очевидно, какую версию каждого блока сохранить. Возможно, вам придется обсудить это с другими разработчиками, которые совершили код.
проверьте ответы в вопросе переполнения стека прерывание слияния в Git, особенно ответ Чарльза Бейли который показывает, как просматривать различные версии файла с проблемами, например,
конфликты слияния происходят, когда изменения вносятся в файл одновременно. Вот как это решить.
git командной строки
вот простые шаги, Что делать, когда вы попадаете в конфликтное состояние:
разрешите конфликты отдельно для каждого файла одним из следующих подходов:
используйте GUI для решения конфликты: git mergetool (самый простой способ).
однако вы должны быть осторожны, так как удаленные изменения, что конфликты были сделаны по какой-то причине.
DiffMerge
Я успешно использовал DiffMerge который может визуально сравнивать и объединять файлы в Windows, macOS и Linux/Unix.
он графически может отображать изменения между 3 файлами и позволяет автоматическое слияние (когда это безопасно) и полный контроль над редактированием результирующего файла.
изображение: DiffMerge (скриншот в Linux)
просто загрузите его и запустите в репо as:
macOS
на macOS вы можете установить через:
и, вероятно (если не указано), вам нужна следующая дополнительная простая обертка, помещенная на вашем пути (например, /usr/bin ):
затем вы можете использовать следующие сочетания клавиш:
в качестве альтернативы вы можете использовать opendiff (часть инструментов Xcode), которая позволяет объединить два файла или каталога вместе, чтобы создать третий файл или каталог.
посмотреть Как Представлены Конфликты или, в Git, git merge документация, чтобы понять, что такое маркеры конфликтов слияния.
и как разрешить конфликты раздел объясняет, как разрешить конфликты:
, увидев конфликт, вы можете сделать две вещи:
разрешить конфликты. Git будет отмечать конфликты в рабочем дереве. Отредактируйте файлы в форму и git add их в индекс. Использовать git commit чтобы скрепить сделку.
вы можете работать через конфликт с рядом инструментов:
используйте mergetool. git mergetool для запуска графического mergetool, который будет поработайте над слиянием.
посмотрите на различия. git diff покажет трехсторонний diff, выделяя изменения от обоих HEAD и MERGE_HEAD версий.
сначала покажет различия для HEAD версия, а потом MERGE_HEAD версия.
смотреть на оригиналы. git show :1:filename показывает общего предка, git show :2:filename показывает HEAD версия, и git show :3:filename показывает MERGE_HEAD версия.
вы также можете прочитать о маркерах конфликтов слияния и о том, как их разрешить в Pro Git раздел книги Основные Конфликты Слияния.
на Emacs пользователи, которые хотят разрешить конфликты слияния полу-вручную:
показывает все файлы, требующие разрешения конфликтов.
открыть каждый из этих файлов по одному, или все сразу:
при посещении буфера, требующего редактирования в Emacs, введите
Это откроет три буфера (мой, их и выходной буфер). Перейдите, нажав » n «(следующая область), » p » (область предвидения). Нажмите ‘a’ и «b», чтобы скопировать мой или их регион в выходной буфер, соответственно. И / или редактировать выходной буфер напрямую.
когда закончите: нажмите «q». Emacs спрашивает вас, Хотите ли вы сохранить этот буфер: да. После завершения буфера отметьте его как разрешенный, запустив из териминала:
когда закончите со всеми буферами типа
для завершения слияния.
пожалуйста, выполните следующие действия, чтобы исправить конфликты слияния в Git:
проверьте состояние Git: git статус
получить набор патчей: git fetch (проверьте правильный патч из вашего git commit)
проверка локальной ветви (temp1 в моем примере здесь): git checkout-b temp1
запустите mergetool и проверьте конфликты и исправьте их. и проверьте изменения в удаленной ветви с вашей текущей веткой: git mergetool
проверьте состояние еще раз: git статус
удаление нежелательных файлов, локально созданных mergetool, обычно mergetool создает дополнительный файл с *.расширение ориг. Удалите этот файл, поскольку это просто дубликат и исправьте изменения локально и добавьте правильную версию своих файлов. git добавить #your_changed_correct_files
проверьте состояние еще раз: git статус
нажимаем в ветку master: git push (в ваш репозиторий Git)
просто, если вы хорошо знаете, что изменения в одном из репозиториев не важны, и хотите разрешить все изменения в пользу другого, используйте:
разрешить изменения в пользу хранилище или
разрешить изменения в пользу другое или главное хранилище.
и после завершения файла вам нужно будет сохранить и закрыть, чтобы открыть следующий.
Я либо хочу свою или их версию в полном объеме, либо хочу просмотреть отдельные изменения и решить для каждого из них.
полностью примите мою или их версию:
примите мою версию (локальную, нашу):
примите их версию (удаленную, их):
если вы хотите сделать для всех файлов конфликтов run:
просмотрите все изменения и примите их индивидуально
по умолчанию mergetool работает в командная строка. Как использовать командную строку mergetool должен быть отдельный вопрос.
вы также можете установить визуальный инструмент для этого, например, meld и работать
вы можете исправить конфликты слияния несколькими способами, как другие подробно.
Я думаю, что реальный ключ знает, как изменения протекают с локальными и удаленными репозиториями. Ключ к этому-понимание ветвей отслеживания. Я обнаружил, что я думаю о ветви отслеживания как о «недостающей части посередине» между моим локальным, фактическим каталогом файлов и удаленным, определенным как origin.
у меня лично вошло в привычку 2 вещи, чтобы помочь избежать этот.
a) все новые/измененные файлы добавляются, и это может включать некоторые нежелательные изменения.
b) вы не можете сначала просмотреть список файлов.
поэтому вместо этого я делаю:
[обновление-по прошествии времени я переключился больше на:
кроме того (и более уместно в вашей ситуации), я стараюсь избегать:
потому что pull подразумевает слияние, и если у вас есть изменения локально, которые вы не хотите объединять, вы можете легко получить объединенный код и / или объединить конфликты для кода, который не должен был быть слитый.