Introduction

Git is a powerful version control system that allows developers to track changes in their code projects efficiently. One key feature of Git is the ability to cherry-pick commits, a process that can be incredibly useful in specific situations. In this blog post, we will explore what cherry-picking a commit means, how it works in Git, and the benefits it offers to developers.

What is cherry-picking a commit?

Cherry-picking a commit refers to the act of selecting a specific commit from one branch and applying it to another branch. This allows developers to choose individual changes and bring them into a different context without merging the entire branch. In essence, cherry-picking allows for the targeted inclusion of changes from one branch to another.

In Git, cherry-picking works by creating a new commit in the target branch that replicates the changes made in the selected commit. This new commit has a unique hash and history separate from the original commit. By cherry-picking commits, developers can pick and choose the changes they want to incorporate, maintaining a high level of control over the codebase.

Benefits of cherry-picking commits include the ability to selectively add features or bug fixes to specific branches, keeping the codebase clean and organized. This can be particularly useful when working on multiple branches simultaneously or when only certain changes need to be applied to a different branch.

How to cherry-pick a commit in Git

Cherry-picking a commit in Git involves several steps that are relatively straightforward once you understand the process. Here is a step-by-step guide on how to cherry-pick a commit:

Step 1: Identify the Commit to Cherry-Pick

First, find the commit hash (also called the SHA) of the commit you want. You can see a list of recent commits using:

git log

You’ll get an output listing commits in reverse chronological order. Each commit has a unique hash, for example, abcdef1234567....

Step 2: Check Out the Branch You Want to Apply the Commit To

Let’s say you want to apply the commit to the main branch. You’d do:

git checkout main

Or, if you’re using Git 2.23 or higher, you might prefer the newer command

git switch main

Step 3: Cherry-Pick the Commit

Now, run:

git cherry-pick <commit-hash>

where <commit-hash> is the hash of the commit you want to bring over. Git will then apply the changes from that commit onto your current branch (main).

Step 4: Resolve Any Conflicts (If Needed)

If there are changes in main that conflict with the cherry-picked commit, Git will pause and let you resolve them. You’ll see conflict markers in the files, just like any other merge conflict.

1. Open the file(s) with conflicts and decide how to combine changes.
2. Mark the file(s) as resolved:bashCopyEdit

git add <filename>

Finish the cherry-pick:

git cherry-pick --continue

If you decide the changes are not needed, you can cancel the cherry-pick:

git cherry-pick --abort

Example in Action

Let’s walk through a simple example:

Scenario

• Branch feature-XYZ has two commits:
  • A bug fix (commit hash a1b2c3d4)
  • A new feature (commit hash f6g7h8i9)
• You only want the bug fix (a1b2c3d4) on the main branch.

Here’s how you do it:

1. Find commit hash:

git checkout feature-XYZ
git log

You see something like:

commit f6g7h8i9 (HEAD -> feature-XYZ)
Author: You <you@example.com>
Date:   Mon Feb 20 12:00:00 2025 +0000

    Add new feature

commit a1b2c3d4
Author: You <you@example.com>
Date:   Mon Feb 20 11:00:00 2025 +0000

    Fix bug #123

The commit you want is a1b2c3d4.

Switch to main:

git checkout main

Or

git switch main

Cherry-pick:

git cherry-pick a1b2c3d4

Git applies the bug fix to main.

Check for conflicts:

• If there are no conflicts, Git completes the cherry-pick and commits it.
• If you do have conflicts, Git stops and asks you to resolve them, after which you’d do:

git add <resolved-file>
git cherry-pick --continue

Verify:

git log

You should now see a commit titled “Fix bug #123” in your main branch’s history.

Best Practices & Things to Note

Use Cherry-Picking Sparingly:
While it’s a powerful tool, overusing cherry-picks can create a fragmented history. If you find yourself constantly cherry-picking multiple commits, consider restructuring your branches or using rebases and merges more strategically.

Keep Commit History Clean:
After cherry-picking, the commit ID changes because you’re effectively creating a new commit in the target branch. Git will maintain the original commit message (unless you edit it), but it’s still a distinct commit in the new branch.

Avoid Confusion:
If a commit is cherry-picked multiple times, it can be hard to track which branch has the “real” commit. Some teams add a note to the commit message, like “[cherry-pick from <branch>]” to indicate the source.

Conflict Management:
If you anticipate major conflicts, weigh whether merging or rebasing might be simpler. Cherry-picking is most straightforward when you need a small, isolated change.

Conclusion

Cherry-picking in Git is a convenient way to grab a single commit from one branch and apply it to another, without merging or rebasing an entire branch. It’s perfect for critical bug fixes, small feature tweaks, or any situation where you need a selective, surgical approach to Git history.

Remember to keep a clean workflow—use cherry-pick for those one-off commits that truly need to be extracted, and rely on merges or rebases for more significant, ongoing development. With these pointers, you’ll be well-prepared to handle the occasional “just one commit, please!” scenarios that inevitably come your way in software development.

FAQs

What is the difference between cherry-picking and merging in Git?

Cherry-picking involves selecting individual commits to apply to another branch, while merging combines the entire history of one branch into another. Cherry-picking allows for more targeted changes, while merging brings in all changes from a branch.

Can I cherry-pick multiple commits at once?

Yes, you can cherry-pick multiple commits at once by specifying a range of commits or individual commit hashes. This can be useful when you need to apply several related changes to a different branch.

What happens if there are conflicts while cherry-picking a commit?

Conflicts may occur when the changes in the cherry-picked commit conflict with the existing code in the target branch. You will need to resolve these conflicts manually before committing the changes.

Can I undo a cherry-pick in Git?

Yes, you can undo a cherry-pick by using the git reset --hard HEAD^ command to reset the current branch to the previous commit before the cherry-pick.

How do I know which commit to cherry-pick?

You can determine which commit to cherry-pick by reviewing the commit history and identifying the changes that need to be applied to another branch. Consider the impact of each commit and choose the ones that are relevant to the target branch.

Conclusion

Cherry-picking commits in Git is a valuable tool that allows developers to selectively apply changes to different branches. By understanding how cherry-picking works and following best practices, you can streamline your development process and maintain a clean codebase. Experiment with cherry-picking commits in your projects to see the benefits firsthand and enhance your version control workflow.

Hire Play Framework Developers