Git Cherry-Pick: Как выбрать и применить определенные коммиты

Учебники
Git

Работа с ветками в совместных средах разработки программного обеспечения необходима для изоляции функций, исправлений ошибок или экспериментов. Однако бывают случаи, когда необходимо взять конкретные изменения из одной ветки и применить их к другой без слияния всей ветки. Здесь git cherry-pick становится незаменимым.

Цель этого руководства – предоставить всеобъемлющее руководство о том, как эффективно использовать git cherry-pick. Вы узнаете синтаксис команды, научитесь справляться с конфликтами и изучите лучшие практики и распространенные ошибки, которых следует избегать. Давайте начнем!

Что такое Git Cherry-Pick?

Команда git cherry-pick является основной командой Git, которая дает разработчикам детальный контроль над их исходным кодом.

В отличие от других операций Git, таких как merge или rebase, которые работают с целыми ветками, cherry-pick позволяет вам выбирать конкретные коммиты из одной ветки и применять их к другой. Это обеспечивает точность, особенно в сценариях, когда вам нужно интегрировать только определенные изменения, а не все модификации в ветке.

Команда git cherry-pick работает, копируя содержимое выбранных коммитов и создавая новые в целевой ветке, сохраняя целостность истории коммитов.

Когда использовать git cherry-pick

Сценарии использования git cherry-pick включают:

  • Возврат исправлений ошибок: Вы устранили ошибку в своей ветке разработки и вам нужно тот же исправление в стабильной или релизной ветке. Cherry-picking позволяет переместить исправление ошибки без переноса нерелевантных изменений.
  • Применение исправлений: Когда производство требует критического исправления, а ветки разработки продолжают развиваться, cherry-picking позволяет извлечь и применить исправление к производственной ветке.
  • Изоляция функций для тестирования: Во время тестирования может потребоваться протестировать только определенные коммиты, связанные с функцией. Вместо слияния всей ветки функции, cherry-picking необходимых коммитов позволяет держать тестовую ветку чистой и эффективной.
  • Исправление неправильно размещенных коммитов: Если коммит был ошибочно отправлен в неправильную ветку, вы можете сделать cherry-pick коммита в соответствующую ветку, не нарушая историю проекта.
  • Повторное использование изменений в нескольких ветках: В случаях, когда вам нужно применить одно и то же обновление в нескольких ветках, cherry-pick позволяет реплицировать изменения в разных ветках без повторения работы или введения сложности с ветками.

Синтаксис Git Cherry-Pick

Понимание синтаксиса git cherry-pick – ключ к эффективному использованию этой команды. Здесь не только выбор коммитов, но и точное их применение для достижения желаемого результата.

Основным синтаксисом для выборочного взятия одного коммита является:

git cherry-pick <commit-hash>
  • git cherry-pick: Команда, которая инициирует операцию.
  • <commit-hash>: Уникальный идентификатор (SHA-1 хеш) коммита, который вы хотите взять. Этот хеш можно найти, запустив git log, чтобы отобразить историю коммитов.

При выполнении вышеуказанной команды Git применяет изменения из указанного коммита к текущей ветке, создавая новый коммит с теми же изменениями, но с другим хешем.

Важно отметить, что команда переносит только сам коммит, а не контекст или историю родительской ветки.

Вы новичок в Git и GitHub? Начните с управления версиями в этом дружелюбном учебнике по GitHub и Git.

Как использовать Git Cherry-Pick: пошаговые примеры

Теперь, когда вы понимаете основный синтаксис git cherry-pick, пора увидеть команду в действии.

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

Пример 1: Cherry-pick одного коммита

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

  • Сначала найдите хеш коммита, который вы хотите взять черри-пиком, запустив:
git log
  • Найдите хеш коммита. 
  • Переключитесь на основную ветку: 
git checkout main
  • Запустите команду cherry-pick (предположим, что хеш – abc1234): 
git cherry-pick abc1234

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

Пример 2: Выборочное копирование нескольких коммитов

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

  • Найдите хэши коммитов для каждого коммита, который вы хотите выборочно скопировать, используя git log:
git log
  • Переключитесь на ветку main:
git checkout main
  • Выполните команду cherry-pick, перечислив коммиты:
git cherry-pick abc1234 def5678 ghi7890

Пример 3: Выбор коммитов в диапазоне

Предположим, вы сделали серию коммитов в ветке feature и хотите применить их к основной ветке сразу, не указывая каждый коммит отдельно. Как бы вы это сделали?

  • Используйте git log для определения начального и конечного коммитов, которые вы хотите выбрать (например, от abc1234 до ghi7890).
  • Переключитесь на основную ветку:
git checkout main
  • Выполните команду cherry-pick с диапазоном коммитов: 
git cherry-pick abc1234...ghi7890

Пример 4: Выбор коммита из удаленной ветки

Иногда критическое исправление существует в удалённой ветке, и вы хотите применить его к своей локальной ветке, не сливая всю ветку. Вот как это сделать:

  • Получите последние изменения из удалённого репозитория
git fetch origin
  • Просмотрите коммиты в удалённой ветке, чтобы найти нужный вам хэш:
git log origin/feature_branch --oneline
  • Предположим, что нужный вам хэш коммита – abc1234.
  • Переключитесь на свою локальную основную ветку:
git checkout main
  • Выберите коммит из удалённой ветки:
git cherry-pick abc1234

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

Нужно проверить удаленную ветку? Следуйте этому пошаговому руководству по Git checkout для удаленных веток.

Пример 5: Выборочное применение коммита и его изменение

Если вы выбираете коммит, но перед фиксацией нужно внести небольшие изменения, вы можете использовать интерактивный режим Git. Вот как:

  • Переключитесь на целевую ветку:
git checkout main
  • Выберите коммит, но остановитесь перед фиксацией:
git cherry-pick -n abc1234

Флаг -n (или --no-commit) применяет изменения, но не создает коммит.

  • Измените файлы по необходимости.
  • Стейджте и коммитте изменения вручную:
git add .
git commit -m "Modified cherry-picked commit from feature_branch"

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

Обработка конфликтов во время cherry-pick в Git

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

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

Как возникают конфликты

Конфликты обычно возникают, когда изменения из cherry-pick коммита перекрываются или противоречат изменениям, уже присутствующим в целевой ветке. Например:

  • Та же строка изменена в обеих ветках: Если одна и та же строка кода изменена как в исходной, так и в целевой ветках, Git не будет знать, какую версию применить.
  • Файл удален в одной ветке, но изменен в другой: Если файл был удален в одной ветке, но изменен в выполненном слиянии коммите, Git не будет знать, стоит ли его сохранить или применить изменения.
  • Не связанные изменения в одном файле: Даже если изменения кажутся несвязанными, если они произошли в одном файле, Git может пометить его как потенциальный конфликт.

Когда возникает конфликт, Git остановит операцию cherry-pick, оставив ваш рабочий каталог в конфликтном состоянии, которое необходимо разрешить перед продолжением.

Разрешение конфликтов

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

1. Проверьте конфликтующие файлы: Выполните следующую команду, чтобы увидеть, какие файлы конфликтуют:

git status

Команда отобразит список файлов с конфликтами.

2. Разрешите конфликты: Вы можете вручную отредактировать конфликтующие файлы, чтобы решить проблемы. Удалите маркеры конфликта (<<<<<<<, =======, >>>>>>>) и определите, какие изменения сохранить или как их объединить.

3. Используйте Git Mergetool (по желанию): Если разрешение конфликтов вручную затруднительно, вы можете использовать инструмент слияния, чтобы помочь визуализировать и разрешить конфликты:

git mergetool

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

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

git add <conflicted-file>

5. Завершите выборочное копирование: После разрешения всех конфликтов и подготовки файлов завершите выборочное копирование, запустив: 

git cherry-pick --continue

Многие современные IDE и инструменты, такие как Visual Studio Code и GitHub, предлагают встроенные функции разрешения конфликтов слияния. Веб-интерфейс GitHub позволяет вам разрешать конфликты непосредственно в запросах на вытягивание (pull requests), что облегчает совместную работу над общими репозиториями без переключения на локальное окружение.

Пропуск коммита после конфликта

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

1. Прервать текущий процесс cherry-pick: Если конфликт слишком сложный, и вы не хотите применять коммит, вы можете пропустить его, запустив: 

git cherry-pick --skip

Это приведет к отмене конфликтного коммита и переходу к следующему (если вы выбираете несколько коммитов).

2. Прервать весь cherry-pick: Если вы хотите полностью прервать операцию cherry-pick, вы можете запустить: 

git cherry-pick --abort

Эта команда восстановит ваш рабочий каталог в состояние, в котором он был до начала cherry-pick.

Хотите очистить историю коммитов? Узнайте, как объединить несколько коммитов в один с помощью этого руководства по сжатию Git.

Лучшие практики использования Git Cherry-Pick

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

Держите все небольшим и конкретным

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

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

Документируйте ваши выборочные копии

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

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

Проверьте историю коммитов

Перед выбором коммита ознакомьтесь с историей коммитов как исходной, так и целевой веток. Этот шаг помогает определить, зависит ли коммит, который вы собираетесь выбрать, от других изменений. Отсутствие зависимостей может привести к неполной функциональности или ошибкам, поэтому убедитесь, что cherry-pick не приведет к появлению “полузапеченных” функций или обновлений.

Избегайте чрезмерного использования cherry-picking

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

Всегда оценивайте, какая стратегия – слияние или ребейзинг – более подходящая перед использованием cherry-pick. Используйте cherry-pick сдержанно и целенаправленно, чтобы избежать загромождения истории коммитов.

Страдаете от ненужных файлов в Git? Узнайте, как эффективно использовать .gitignore с этим уроком по игнорированию в Git.

Устранение распространенных проблем с Git Cherry-Pick

Устранение проблем, которые возникают при использовании cherry-pick, требует четкого понимания основных механизмов Git. В этом разделе я рассмотрю некоторые распространенные проблемы, с которыми вы можете столкнуться при cherry-picking, и как их решить.

Cherry-pick коммита, который не существует

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

1. Коммит не найден: Это происходит, когда хэш коммита, который вы пытаетесь взять cherry-pick, не существует в вашем текущем репозитории или контексте ветки. Убедитесь, что вы обращаетесь к правильному коммиту, проверив историю коммитов с помощью git log на ветке, где существует коммит. Решение:

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

2. Применить уже примененный коммит: Если коммит уже был объединен или перенесен в целевую ветку, Git предотвратит дублирование. Эта защита помогает поддерживать чистую и избегать избыточных изменений. Решение:

  • Используйте git log, чтобы проверить, был ли коммит уже в целевой ветке.
  • При необходимости пропустите операцию cherry-pick, поскольку изменения уже были применены.

Cherry-picking после перебазирования или слияния

Cherry-picking после перебазирования или слияния может привести к сложностям из-за измененной истории ваших веток. Перебазирование переписывает историю коммитов, а слияние объединяет ветки, что может повлиять на применимость cherry-pick.

1. Конфликты из-за перебазированных коммитов: После перебазирования история коммитов переписывается, что может вызвать проблемы, если вы пытаетесь выбрать коммиты, которые были изменены во время процесса перебазирования. Могут возникнуть конфликты, так как cherry-pick пытается применить изменения, которые не соответствуют переписанной истории. Решение:

  • Тщательно просмотрите историю коммитов после перебазирования с помощью git log, чтобы убедиться, что коммит, который вы пытаетесь выбрать, не был уже изменен.
  • Разрешайте конфликты так же, как вы это делали бы в стандартном процессе cherry-pick, используя git status и ручные правки.

2. Дублирование коммитов после слияния: Слияние веток может привести к ситуации, когда коммит, который вы хотите выбрать, уже был включен в объединенную историю. Повторный выбор этого коммита может привести к дублирующимся коммитам, что может загромождать вашу историю и усложнять отслеживание изменений. Решение:

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

Нужно отменить изменения в Git? Узнайте, когда использовать git reset и git revert в этом учебнике по сбросу и откату Git.

Заключение

git cherry-pick – это мощный способ применить конкретные коммиты из одной ветки в другую, не сливая всю ветку. Независимо от того, перемещаете ли вы исправление ошибки, обновление функции или применяете изменения выборочно, это помогает поддерживать вашу историю Git чистой и сфокусированной.

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

Если вы хотите углубить свои навыки Git, ознакомьтесь с курсом Foundations of Git для крепкой отправной точки. Вы также можете изучить Introduction to GitHub Concepts или пройти структурированный подход с GitHub Foundations skill track.

Теперь, когда вы знаете, как использовать cherry-pick как профессионал, приступайте и попробуйте это в своем следующем проекте!

Source:
https://www.datacamp.com/tutorial/git-cherry-pick