What is Git cherry-picking?

Whenever you're working with a group of programmers on a project, whether small or large, handling changes between multiple Git branches can become difficult. Sometimes, instead of combining an entire Git branch into a different one, you want to select and move a couple of specific commits. This procedure is known as "cherry-picking."

This article will cover the what, why, and how of cherry-picking.

So let's start.

What is cherry-pick?

With the cherry-pick command, Git lets you incorporate selected individual commits from any branch into your current Git HEAD branch.

When performing a git merge or git rebase, all the commits from a branch are combined. The cherry-pick command allows you to select individual commits for integration.

Benefits of cherry-pick

The following situation might make it easier to comprehend the way cherry-picking functions.

Imagine you are implementing new features for your upcoming weekly sprint. When your code is ready, you will push it into the remote branch, ready for testing.

However, the customer is not delighted with all of the modifications and requests that you present only certain ones. Because the client hasn't approved all changes for the next launch, git rebase wouldn't create the desired results. Why? Because git rebase or git merge will incorporate every adjustment from the last sprint.

Cherry-picking is the answer! Because it focuses only on the changes added in the commit, cherry-picking brings in only the approved changes without adding other commits.

There are several other reasons to use cherry-picking:

• It is essential for bug fixing because bugs are set in the development branch using their commits.
• You can avoid unnecessary battles by using git cherry-pick instead of other options that apply changes in the specified commits, e.g., git diff.
• It is a useful tool if a full branch unite is impossible because of incompatible versions in the various Git branches.

Using the cherry-pick command

In the cherry-pick command's simplest form, you can just use the SHA identifier for the commit you want to integrate into your current HEAD branch.

To get the commit hash, you can use the git log command:

$ git log --oneline

Once you know the commit hash, you can use the cherry-pick command.

The syntax is:

$ git cherry-pick <commit sha>

For example:

$ git cherry-pick 65be1e5

This will dedicate the specified change to your currently checked-out branch.

If you'd like to make further modifications, you can also instruct Git to add commit changes to your working copy.

The syntax is:

$ git cherry-pick <commit sha> --no-commit

For example:

$ git cherry-pick 65be1e5 --no-commit

If you would like to select more than one commit simultaneously, add their commit hashes separated by a space:

$ git cherry-pick hash1 hash3

When cherry-picking commits, you can't use the git pull command because it fetches and automatically merges commits from one repository into another. The cherry-pick command is a tool you use to specifically not do that; instead, use git fetch, which fetches commits but does not apply them. There's no doubt that git pull is convenient, but it's imprecise.

Try it yourself

To try the process, launch a terminal and generate a sample project:

$ mkdir fruit.git
$ cd fruit.git
$ git init .

Create some data and commit it:

$ echo "Kiwifruit" > fruit.txt
$ git add fruit.txt
$ git commit -m 'First commit'

Now, represent a remote developer by creating a fork of your project:

$ mkdir ~/fruit.fork
$ cd !$
$ echo "Strawberry" >> fruit.txt
$ git add fruit.txt
$ git commit -m 'Added a fruit"

That's a valid commit. Now, create a bad commit to represent something you wouldn't want to merge into your project:

$ echo "Rhubarb" >> fruit.txt
$ git add fruit.txt
$ git commit -m 'Added a vegetable that tastes like a fruit"

Return to your authoritative repo and fetch the commits from your imaginary developer:

$ cd ~/fruit.git
$ git remote add dev ~/fruit.fork
$ git fetch dev
remote: Counting objects: 6, done. 
remote: Compressing objects: 100% (2/2), done. 
remote: Total 6 (delta 0), reused 0 (delta 0) 
Unpacking objects: 100% (6/6), done...

$ git log –oneline dev/master
e858ab2 Added a vegetable that tastes like a fruit 
0664292 Added a fruit 
b56e0f8 First commit

You've fetched the commits from your imaginary developer, but you haven't merged them into your repository yet. You want to accept the second commit but not the third, so use cherry-pick:

$ git cherry-pick 0664292

The second commit is now in your repository:

$ cat fruit.txt
Kiwifruit
Strawberry

Push your changes to your remote server, and you're done!

Reasons to avoid cherry-picking

Cherry-picking is usually discouraged in the developer community. The primary reason is that it creates duplicate commits, but you also lose the ability to track your commit history.

If you're cherry-picking a lot of commits out of order, those commits will be recorded in your branch, and it might lead to undesirable results in your Git branch.

Cherry-picking is a powerful command that might cause problems if it's used without a proper understanding of what might occur. However, it may save your life (or at least your day job) when you mess up and make commits to the wrong branches.