How to Use git cherry-pick in Git?

In Git, sometimes you want to apply a specific commit from one branch to another without merging everything from the source branch. This is where git cherry-pick comes into play. Cherry-picking allows you to selectively apply commits from one branch to another, making it an essential tool for managing features, bug fixes, and hotfixes. In this post, we’ll explain what cherry-picking is, when to use it, and how to apply it effectively.

---

What is Git Cherry-Picking?

Cherry-picking in Git refers to applying specific commits from one branch onto another branch. Unlike merging or rebasing, which brings in all commits from a source branch, cherry-picking is selective. It’s particularly useful when you want to incorporate specific features or fixes from one branch into another without affecting the entire branch’s history.

Example Use Cases for Cherry-Picking:

1. Hotfixes: Apply a single bug fix from a feature branch to the main branch.
2. Selective Updates: Bring only certain commits into a release branch without integrating other ongoing development.
3. Cross-Branch Features: Apply specific features developed in one branch to another feature branch.

---

How to Cherry-Pick a Commit in Git

To cherry-pick a commit, you’ll need the commit hash of the change you want to apply. You can find this using git log or another Git interface.

Step 1: Identify the Commit to Cherry-Pick

Navigate to the branch with the commit you want to cherry-pick, then use git log to locate the commit hash:

git log

The log will display recent commits. Copy the hash (a unique identifier) of the commit you want to cherry-pick, which will look like abc1234.

Step 2: Check Out the Target Branch

Switch to the branch where you want to apply the commit:

git checkout <target-branch>

For example, if you’re applying a hotfix to main, you’d check out the main branch:

git checkout main

Step 3: Cherry-Pick the Commit

Now, use the git cherry-pick command along with the commit hash to apply the change:

git cherry-pick <commit-hash>

For example:

git cherry-pick abc1234

This command will apply the changes from that commit to your current branch. If there are no conflicts, it will create a new commit with those changes.

---

Cherry-Picking Multiple Commits

If you need to apply several commits at once, you can specify multiple commit hashes:

git cherry-pick <commit-hash1> <commit-hash2> <commit-hash3>

Or, if the commits are consecutive, you can specify a range of commits:

git cherry-pick <starting-hash>^..<ending-hash>

The ^ before the first hash ensures you’re including it in the range.

---

Handling Cherry-Pick Conflicts

If Git encounters conflicts while applying a cherry-picked commit, it will pause the cherry-pick and prompt you to resolve the conflicts manually. Here’s how to proceed if that happens:

1. Resolve Conflicts: Open the conflicted files, identify the changes, and resolve the conflicts.
2. Mark Conflicts as Resolved: After resolving, add the files to the staging area:

   git add <filename>

3. Continue Cherry-Picking: Once all conflicts are resolved, complete the cherry-pick with:

   git cherry-pick --continue

4. Abort Cherry-Pick: If you decide not to proceed with the cherry-pick, you can abort it with:

   git cherry-pick --abort

---

Cherry-Pick with Commit Message Modification

If you want to edit the commit message of the cherry-picked commit, use the -e flag:

git cherry-pick -e <commit-hash>

This will open your editor, allowing you to modify the commit message as needed.

---

Best Practices for Cherry-Picking

1. Use Sparingly: Cherry-picking can lead to a fragmented history if overused. Use it only when necessary, and consider whether a merge or rebase might be a better solution.
2. Document Cherry-Picks: When applying hotfixes or specific features with cherry-pick, note this in the commit message to clarify why certain changes were selectively brought in.
3. Avoid Cross-Branch Cherry-Picking: Cherry-picking across unrelated branches (like from a feature branch to a release branch) can complicate your project’s history. Use this approach primarily within branches related to the same project scope.

---

Common Cherry-Pick Scenarios

1. Applying a Hotfix to Production

Suppose you have a bug fix on your development branch that needs to go to production immediately. You can cherry-pick the bug fix commit onto the main branch and push it to production without merging the entire development branch.

2. Adding a Specific Feature to a Release Branch

If a particular feature is ready to go live but is part of an ongoing development branch, you can cherry-pick the feature’s commit into the release branch, bringing it in without including incomplete work.

3. Undoing a Cherry-Picked Commit

If you mistakenly cherry-pick a commit, you can undo it by finding the hash of the unwanted commit and using git revert:

git revert <cherry-picked-commit-hash>

---

Summary

Cherry-picking in Git is a powerful feature that enables developers to selectively apply commits from one branch to another, providing flexibility when managing features, hotfixes, and custom updates. By carefully selecting and applying commits with git cherry-pick, you can streamline your development workflow, minimize conflicts, and ensure that essential changes reach the appropriate branches without disrupting other work. Remember to use cherry-picking judiciously to maintain a clean project history and reduce the risk of introducing inconsistencies.

Whether you’re managing production hotfixes, feature integration, or one-off bug fixes, cherry-picking can be an invaluable tool in your Git toolkit.