Essential Guide

Browse Sections

BACKGROUND IMAGE: deepagopi2011/

This content is part of the Essential Guide: Master Git basics and branch into DVCS
News Stay informed about the latest enterprise technology news and product updates.

Learn to git cherry-pick a commit with this easy example

One of the most commonly misunderstood version control commands is git cherry-pick, and that’s a real shame because the ability to git cherry-pick a commit is one of the most useful skills a developer can employ when trying to isolate a software bug or fix a broken build.

how to git cherry-pick a commit.

Figure 1. If you see a commit you like, just git cherry-pick it.

What is git cherry-pick?

According to the official git documentation, the goal of a cherry-pick is to “apply the changes introduced by some existing commit.” Essentially, a cherry-pick will look at a previous commit in the repository’s history and apply the changes that were part of that earlier commit to the current working tree. The definition is seemingly straight forward, yet in practice there is a great deal of confusion over what exactly happens when someone tries to git cherry-pick a commit, or even cherry-pick from another branch. This git cherry-pick example will eliminate that confusion.

A git cherry-pick example

We will begin this git cherry-pick example with a completely clean repository, which means first you will create a new folder, which we will name git cherry-pick tutorial, and then issuing a git init command from within it.

/c/ git cherry-pick tutorial
$ git init
Initialized empty Git repository in C:/ git cherry-picktutorial/.git/

With the git repository initialized, create five html files, and each time a you create a file, perform a commit. In each commit message, the commit number and the number of files in the working tree will be included as part of the commit message. In a subsequent step, where we cherry-pick a commit, it is one of these commit steps that will be chosen.

Here are the commands to create the five, alphabetically ordered .html files along with the git commands required to add each file independently to the git index and subsequently commit those files to the repository:

/c/ git cherry-pick tutorial
$ echo 'alpha' > alpha.html
$ git add . | git commit -m "1st commit: 1 file"

$ echo 'beta' > beta.html
$ git add . | git commit -m "2nd commit: 2 files"

$ echo 'charlie' > charlie.html
$ git add . | git commit -m "3rd commit: 3 files"

$ echo 'whip it' > devo.html
$ git add . | git commit -m "4th commit: 4 files"

$ echo 'Big Lebowski' > eagles.html
$ git add . | git commit -m "5th commit: 5 files"

A note on the echo command

The echo command will be used as a file creation shortcut. For those unfamiliar with this shortcut, echoing text and then specifiying a file name after the greater-than sign will create a new file with that name, containing the text that was echoed. So the following command will create a new file named agenda.html with the word devops contained within it:

$ echo 'devops' > agenda.html

Delete and commit before the cherry-pick

We will now delete all five recently created files to clear out the working directory. A subsequent commit will be needed here as well.

/c/ git cherry-pick tutorial
$ rm *.html
$ git add . | git commit -m "all deleted: 0 files"

To recap, five files were created, and each file created has a corresponding commit. And then all the files were deleted and a sixth commit was issued. A chronicling of this commit history can be concisely viewed in the reflog. Take special note of the hexadecimal  identifier on the third commit, which we will cherry-pick in a moment:

/c/ git cherry-pick tutorial
$ git reflog
189aa32 HEAD@{0}: commit: all deleted: 0 files
e6f1ac7 HEAD@{1}: commit: 5th commit:  5 files
2792e62 HEAD@{2}: commit: 4th commit:  4 files
60699ba HEAD@{3}: commit: 3rd commit:  3 files
4ece4c7 HEAD@{4}: commit: 2nd commit:  2 files
cc6b274 HEAD@{5}: commit: 1st commit:  1 file

What happens when we git cherry-pick a commit?

This is where the git cherry-pick example starts to get interesting. We need to git cherry-pick a commit, so let’s choose the third commit where the file named charlie.html was created. But before we do, ask yourself what you believe will happen after the command is issued. When we git cherry-pick a commit, will we get all of the files associated with that commit, which would mean alpha.html, beta.html and charlie.html will come back? Or will we get just one file back? Or will the attempt to git cherry-pick a commit fail since all of the files associated with the commit have been deleted from our workspace?

The git cherry-pick command

Here is the command to git cherry-pick commit number 60699ba:

/c/ git cherry-pick tutorial (master)
$ git cherry-pick 60699ba

[master eba7975] 3rd commit: 3 files
1 file changed, 1 insertion(+)
create mode 100644 charlie.html

As you can see, only one file was added to the working directory, namely charlie.html. The files that were added to the repository in prior commits were not added, which tends to be the expectation of many users. Many users believe that when you git cherry-pick a commit, all of the files that are part of that branch, at that time of the commit, will be brought into the working directory. This is obviously not the case. When you git cherry-pick a commit, only the change associated with that commit is re-applied to the working tree.

The git cherry-pick command

Here are the various options available when issuing a git cherry-pick for a commit.

A hidden git cherry-pick commit

It should also be noted that it’s not just the working tree that is updated. When you git-cherry-pick a commit, a completely new commit is created on the branch, as the following reflog command indicates:

/c/ git cherry-pick tutorial (master)
$ git reflog
eba7975 HEAD@{0}: cherry-pick: 3rd commit: 3 files
189aa32 HEAD@{1}: commit: all deleted: 0 files
e6f1ac7 HEAD@{2}: commit: 5th commit: 5 files
2792e62 HEAD@{3}: commit: 4th commit: 4 files
60699ba HEAD@{4}: commit: 3rd commit: 3 files
4ece4c7 HEAD@{5}: commit: 2nd commit: 2 files
cc6b274 HEAD@{6}: commit (initial): 1st commit: 1 file

When a developer encounters a problem in the repository, the ability to git cherry-pick a commit can be extremely helpful in fixing bugs and resolving problems in GitHub, which is why understanding how the command works and the impact it will have on the current development branch is pivotal. Hopefully, with this git cherry-pick example under your belt, you will have the confidence needed to use the command to resolve problems in your own development environment.

Further improve your DevOps tools knowledge

Mastered Git? The next step in your DevOps journey is mastering Jenkins CI. Here are some great Jenkins tutorials that will take you from beginner to expert.

Step 1 — How to download, configure and install Jenkins tutorial

Step 2 — Create your first Jenkins freestyle build job example

Step 3 — Pull from the Jenkins environment variables list in your shell scripts

Step 4 — Fix common Jenkins plugin installation errors

Step 5 — Add String and Boolean Jenkins parameters to your builds

Step 6 — Start pulling from GitHub with the Jenkins Git plugin

Step 7 — What happens when you git reset hard and push?

Step 8 — Get a handle on the  Jenkins vs. Maven debate

Step 9 — Learn how to do a hard git reset on a commit

Join the conversation


Send me notifications when other members comment.

Please create a username to comment.

Which "as a service" delivery model is your company using, or planning to use?
PaaS empowers the non technical user to build solutions without the need for developers or other IT resources. Like any new innovation that matures, we will soon reminisce " remember how difficult it was to build applications" .
If you plan to deploy your apps on cloud , that's is Paas.
Many cloud companies today are approaching smallar companies to become their viable customer. The question is now about the cloud security that is something customer looking for. Anyway the cloud business is going to grow and the job market now needs cloud expertise that has yet to be analyzed how many people have proper training on cloud computing.
The next generation PaaS platforms will allow a business analyst or a non-programmer to build and deploy cloud based business applications.
The real challenge is the service needed to get ready for XaaS at the company side.
Every generation has a computer trend they dance to. It's still a computer with a CPU, RAM, Disk and a Wire to talk to it. Marketing changes the same platform into concepts as its technical abilities increase and the next generation spends 20 years, billions of dollars doing the same thing, over and over. The next big thing is to change the name of Cloud Computing. It not longer applies. It's now raining and creating a flood of definitions to fool the inexperienced and the know-it-alls. Get with the cool kids and spend spend spend. The answer to all things for the next generation of computer folks is simple...Water Technology. Water is superior to cloud, transmits 4 x times faster, maintains solid (physical), liquid (virtual) and gaseous (wireless), states and cannot be harmed or destroyed, as it is capable of recombining into it's original state. Look for next gen articles on Water technology. The Super Secret is now out of the bag.
A flippant note on the confounding PaaS.
Until the thinner parsing layer between IaaS and PasS , or the convergence of these are clearly articulated, cloud computing is getting more clouder to me. articulated
I love Microsoft Azure!