Merging vs. rebasing
Командой git rebase
, словно опасным заклинанием, часто пугают новичков. В действительности она может значительно облегчить жизнь команде разработчиков, если использовать ее правильно. В этой статье проводится сравнение команды git rebase
со схожей командой git merge
и описываются все возможные ситуации, в которых уместно включить перебазирование в стандартный рабочий процесс Git.
Conceptual overview
В первую очередь нужно понимать, что команда git rebase
помогает решить ту же проблему, что и команда git merge
. Обе команды предназначены для включения изменений из одной ветки в другую, но делают это по-разному.
Представьте, что вы начали работать над новой функциональной возможностью в отдельной ветке, после чего другой участник команды добавляет новые коммиты в главную ветку main
. Возникает история форков, знакомая каждому, кто использовал Git для совместной работы.
А теперь предположим, что новые коммиты в главной ветке main
затрагивают функцию, над которой вы работаете. Для включения новых коммитов в свою функциональную ветку feature
можно использовать два варианта: слияние или перебазирование.
![базы данных](https://wac-cdn.atlassian.com/dam/jcr:f05d1440-c0ca-45f1-9f31-f376bb67adf6/databases.png?cdnVersion=2199)
Связанные материалы
Перемещение полного репозитория Git
![Логотип Bitbucket](https://wac-cdn.atlassian.com/dam/jcr:03116c1f-27e5-4a82-9b9b-806786578fb2/logos-bitbucket-icon-gradient-blue-121x109@2x.png?cdnVersion=2199)
СМ. РЕШЕНИЕ
Изучите Git с помощью Bitbucket Cloud
The merge option
Проще всего слияние ветки main
в функциональную ветку выполняется с помощью следующей команды:
git checkout feature
git merge main
При желании этот код можно записать в одну строку:
git merge feature main
Эта операция создает в ветке feature
новый «коммит слияния», связывающий истории обеих веток. Структура веток будет выглядеть так:
Слияние (merge) — это отличная неразрушающая операция. Существующие ветки никак не изменяются. Эта операция позволяет избегать потенциальных проблем, связанных с выполнением команды rebase (и описанных ниже).
С другой стороны, это означает, что каждый раз, когда вам будет необходимо включить вышестоящие изменения, в функциональную ветку feature
будет попадать внешний коммит слияния. Если работа в главной ветке main
ведется активно, история вашей функциональной ветки быстро засорится. Хотя эту проблему можно устранить, используя продвинутые варианты команды git log
, другим разработчикам будет тяжело разобраться в истории проекта.
The rebase option
Вместо слияния можно выполнить перебазирование функциональной ветки feature
на главную ветку main
с помощью следующих команд:
git checkout feature
git rebase main
В результате вся функциональная ветка feature
окажется поверх главной ветки main
, включая в себя все новые коммиты в ветке main
. Если вместо команды merge при коммитах используется rebase, эта команда перезаписывает историю проекта, создавая новые коммиты для каждого коммита в исходной ветке.
Главное преимущество rebase — более чистая история проекта. Во-первых, эта команда устраняет ненужные коммиты слияния, необходимые для git merge
. Во-вторых, как показано на рисунке выше, команда rebase создает идеальную линейную историю проекта — вы сможете отследить функционал
до самого начала проекта без каких-либо форков. Это упрощает навигацию в проекте с помощью таких команд, как git log
, git bisect
и gitk
.
Однако такая безупречная история коммитов требует определенных жертв: жертвовать приходится безопасностью и отслеживаемостью. Если не следовать Золотому правилу Rebase, перезапись истории проекта может обернуться катастрофическими последствиями для совместных рабочих процессов. Кроме того, при выполнении rebase теряется контекст, доступный в коммите со слиянием: вы не сможете увидеть, когда вышестоящие изменения были включены в функционал.
Interactive rebasing
Интерактивная операция rebase позволяет изменять коммиты при их перемещении в новую ветку. Этот вариант предоставляет еще больше возможностей, чем автоматическое выполнение rebase, поскольку дает полный контроль над историей коммитов ветки. Обычно его используют для очистки запутанной истории, перед тем как сливать функциональную ветку в главную ветку main
.
Чтобы запустить интерактивное перебазирование, передайте параметр i
команде git rebase
:
git checkout feature
git rebase -i main
Откроется текстовый редактор. В нем будут перечислены все коммиты, подготовленные к перемещению:
pick 33d5b7a Message for commit #1
pick 9480b3d Message for commit #2
pick 5c67e61 Message for commit #3
Этот список точно отражает, как будет выглядеть ветка после перебазирования. Изменяя команду pick
и (или) порядок коммитов, вы можете придать истории ветки нужный вид. Так, если второй коммит содержит исправление небольшой проблемы в первом, их можно объединить с помощью команды fixup
:
pick 33d5b7a Message for commit #1
fixup 9480b3d Message for commit #2
pick 5c67e61 Message for commit #3
Когда вы сохраните и закроете файл, Git выполнит перебазирование в соответствии с вашими указаниями. История проекта затем примет следующий вид:
Удаление незначительных коммитов помогает быстрее разобраться в истории функциональной ветки. Команда git merge
просто не в состоянии этого сделать.
The golden rule of rebasing
Разобравшись с возможностями rebase, необходимо в первую очередь понять, когда эту команду не нужно использовать. Золотое правило для команды git rebase
— никогда не использовать ее в публичных ветках.
К примеру, представьте, что произойдет, если вы выполните rebase главной ветки main
на свою функциональную ветку feature
.
Перебазирование перемещает все коммиты ветки main
в конец ветки feature
. Проблема в том, что это происходит только в вашем репозитории, в то время как другие разработчики продолжают работать с исходной веткой main
. Поскольку в результате перебазирования создаются абсолютно новые коммиты, Git будет считать, что история вашей главной ветки main
разошлась с остальными.
Единственный способ синхронизировать две главные ветки main
— выполнить их обратное слияние. Это приведет к дополнительному коммиту слияния и двум наборам коммитов, которые содержат одни и те же изменения (исходные изменения и изменения из вашей ветки после rebase). Нужно ли говорить, что ситуация получится крайне запутанная?
Поэтому перед выполнением команды git rebase
следует убедиться, что текущую ветку не просматривает кто-то другой. Если в ней действительно ведется работа, прекратите любые действия и подумайте, как можно внести изменения неразрушающим способом (например, с помощью команды git revert
). В остальных случаях вы можете свободно перезаписывать историю при необходимости.
Force-pushing
Git заблокирует попытку поместить перебазированную ветку main
обратно в удаленный репозиторий, поскольку она вступит в конфликт с удаленной веткой main
. Но эту операцию можно выполнить принудительно, добавив флаг --force
:
# Be very careful with this command! git push --force
При этом удаленная ветка main
станет соответствовать ветке в вашем репозитории после rebase. В итоге путаться начнут и ваши коллеги. Поэтому будьте внимательны и используйте эту команду только в том случае, если полностью понимаете, чего хотите добиться.
Одна из немногих ситуаций, требующих форсированного помещения кода, — это локальная очистка после помещения частной функциональной ветки в удаленный репозиторий (например, для создания резервной копии). Это равноценно заявлению: «Ой, я ведь не хотел отправлять исходную версию этой функциональной ветки. Лучше возьмите текущую версию». Здесь также важно, чтобы никто после коммитов не начал работу из исходной версии функциональной ветки.
Workflow walkthrough
Перебазирование можно использовать при работе с Git ровно в том объеме, который подходит команде. В этом разделе вы узнаете о преимуществах перебазирования на разных этапах разработки функций продукта.
В любом рабочем процессе с применением команды git rebase
сначала нужно создать отдельную ветку для каждой функции. Полученная структура веток необходима для безопасного перебазирования:
Local cleanup
Один из самых эффективных сценариев перебазирования в рабочем процессе — это очистка локальных функциональных веток, в которых еще ведется работа. Если периодически проводить интерактивное перебазирование, ни один коммит в вашей ветке не потеряет смысла. Вы сможете быть уверены, что ваш код не распадется на изолированные коммиты. Если это случится, ситуацию всегда можно будет исправить.
При использовании команды git rebase
есть два варианта для нового положения ветки: вышестоящая ветка для функциональной ветки (например, ветка main
) или более ранний коммит в функциональной ветке. Первый вариант описывался в примере в разделе Интерактивное перебазирование. Второй вариант удобен, когда нужно исправить лишь несколько недавних коммитов. Например, следующая команда запускает интерактивную операцию rebase только для трех последних коммитов.
git checkout feature git rebase -i HEAD~3
Указав HEAD~3
в качестве нового положения, вы не перемещаете ветку как таковую, а лишь интерактивно переписываете 3 последующих коммита. Следует отметить, что при этой операции вышестоящие изменения не включаются в функциональную
ветку.
Если с помощью этого способа вы хотите переписать всю функциональную ветку, найти начальное положение функциональной
ветки поможет команда git merge-base
. Следующая команда возвращает ID коммита начального положения, который затем можно передать в команду git rebase
:
git merge-base feature main
Такое использование интерактивной операции rebase отлично поможет включить git rebase
в рабочий процесс, поскольку затронет только локальные ветки. Другие разработчики увидят только законченную версию с простой и отслеживаемой историей функциональной ветки.
Повторим, что это работает только для частных функциональных веток. Если вы работаете в одной функциональной ветке с другими разработчиками, она является публичной и переписывать ее историю запрещено.
Варианта очистки локальных коммитов с интерактивным использованием rebase с помощью команды git merge
не существует.
Incorporating upstream changes into a feature
В разделе Обзор основных моментов рассматривалось включение вышестоящих изменений из главной ветки main
в функциональную ветку с помощью команды git merge
или git rebase
. Операцию слияния можно выполнять безопасно, поскольку при этом сохраняется вся история репозитория. При выполнении перебазирования создается линейная структура: функциональная ветка перемещается в конец ветки main
.
В этом случае команда git rebase
используется так же, как и локальная очистка (которую можно осуществить одновременно), но при ее выполнении включаются вышестоящие изменения из главной ветки main
.
Помните, что можно еще выполнять rebase в удаленную ветку, отличную от ветки main
. Например, при совместной работе над функциональной возможностью с другим разработчиком, когда требуется включить его изменения в ваш репозиторий.
Например, если вы вместе с разработчиком Джоном добавляли коммиты в ветку feature
, то после получения удаленной ветки feature
из репозитория Джона ваш репозиторий может выглядеть следующим образом:
С таким ветвлением можно работать так же, как и при включении вышестоящих изменений из ветки main
: либо выполнить слияние в локальную ветку feature
для ветки john/feature
, либо выполнить перебазирование локальной ветки feature
на конец ветки john/feature
.
Обратите внимание: такое перебазирование не нарушает «золотое правило», поскольку перемещаются только коммиты вашей ветки feature
, тогда как предшествующие элементы остаются нетронутыми. В сущности, эта операция позволяет лишь добавить ваши изменения к наработкам Джона. Чаще всего это проще, чем выполнять синхронизацию с удаленной веткой посредством коммита слияния.
По умолчанию команда git pull
выполняет слияние. Однако если передать ей параметр --rebase
, будет выполнено перебазирование для удаленной ветки.
Reviewing a feature with a pull request
Если в процессе проверки кода используются пул-реквесты, не используйте команду git rebase
после создания пул-реквеста. Сразу после создания пул-реквеста другие разработчики смогут видеть ваши коммиты, то есть ваша ветка станет публичной. В случае перезаписи ее истории Git и ваши коллеги не смогут отслеживать последующие коммиты в функциональную ветку.
Все изменения, сделанные другими разработчиками, нужно добавлять командой git merge
, а не git rebase
.
Поэтому хорошей идеей является очистка кода с помощью интерактивной операции rebase перед созданием пул-реквеста.
Integrating an approved feature
После одобрения функциональной ветки коллегой вы можете перебазировать ее на конец ветки main
, а затем использовать команду git merge
для включения функциональной ветки в основную базу кода.
Это похоже на включение вышестоящих изменений в функциональную ветку, но поскольку переписывать коммиты в главной ветке main
запрещено, вам придется использовать для включения функциональной ветки команду git merge
. Выполняя перебазирование перед слиянием, вы обеспечиваете ускоренное слияние и идеальную линейную историю. Такой подход также позволяет склеивать любые последующие коммиты, добавленные до закрытия запроса pull.
Если вы еще не привыкли работать с командой git rebase
, всегда можно выполнить rebase во временную ветку. В таком случае, если вы случайно запутаете историю функциональной ветки, всегда можно будет переключиться в исходную ветку и попробовать снова. Например:
git checkout feature
git checkout -b temporary-branch
git rebase -i main
# [Clean up the history]
git checkout main
git merge temporary-branch
Резюме
Теперь у вас достаточно информации, чтобы начать использовать rebase для своих веток. Если вы предпочитаете иметь чистую линейную историю без ненужных коммитов слияния, используйте команду git rebase
вместо git merge
при включении изменений из другой ветки.
Но если вам нужно сохранить полную историю проекта и избежать перезаписи публичных коммитов, воспользуйтесь командой git merge
. Теперь вы можете не только применить слияние, но и оценить преимущества команды git rebase
— оба варианта эффективны в работе.
Поделитесь этой статьей
Следующая тема
Рекомендуемые статьи
Добавьте эти ресурсы в закладки, чтобы изучить типы команд DevOps или получать регулярные обновления по DevOps в Atlassian.
![Люди сотрудничают друг с другом, используя стену со множеством инструментов](https://wac-cdn.atlassian.com/dam/jcr:2642fbab-a771-4961-9648-806c2fff25e5/bitbucket-blog-resized.png?cdnVersion=2199)
Блог Bitbucket
![Рисунок: DevOps](https://wac-cdn.atlassian.com/dam/jcr:d1f1a28b-11fc-4e22-b6c8-d47832b39d53/devops-learning-path-resized.png?cdnVersion=2199)
Образовательные программы DevOps
![Демонстрация функций в демо-зале с участием экспертов Atlassian](https://wac-cdn.atlassian.com/dam/jcr:73c6bd92-448f-4ae7-a6c1-5f4695f78692/demo-den-resized.png?cdnVersion=2199)