The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Cherry-Picking Commits

Next ►
►

Cherry-picking in Git allows you to apply the changes introduced by some existing commits onto your current branch. This can be particularly useful when you want to incorporate specific changes from one branch into another without merging the entire branch.

Key Concepts

  • Commit Hash: A unique identifier for each commit.
  • Current Branch: The branch you are currently working on.
  • Source Branch: The branch from which you want to cherry-pick commits.

When to Use Cherry-Picking

  • To apply a bug fix from one branch to another.
  • To selectively apply features or changes without merging the entire branch.
  • To backport changes to an older release branch.

Step-by-Step Guide

  1. Identifying the Commit to Cherry-Pick

First, you need to identify the commit hash of the commit you want to cherry-pick. You can do this by viewing the commit history of the source branch.

git log <source-branch>

Example output:

commit 1a2b3c4d5e6f7g8h9i0j
Author: John Doe <[email protected]>
Date:   Mon Oct 4 10:00:00 2023 -0400

    Fix issue with user authentication

In this example, the commit hash is 1a2b3c4d5e6f7g8h9i0j.

  1. Switching to the Target Branch

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

git checkout <target-branch>

  1. Cherry-Picking the Commit

Use the git cherry-pick command followed by the commit hash.

git cherry-pick 1a2b3c4d5e6f7g8h9i0j

  1. Resolving Conflicts (if any)

If there are conflicts, Git will pause the cherry-pick process and allow you to resolve them. After resolving the conflicts, you need to continue the cherry-pick process.

# Resolve conflicts in your editor, then:
git add <resolved-files>
git cherry-pick --continue

If you want to abort the cherry-pick process, you can use:

git cherry-pick --abort

Practical Example

Let's say you have a bug fix in the feature-branch that you want to apply to the main branch.

  1. Identify the commit hash in feature-branch:

    git log feature-branch

    Assume the commit hash is abc123.

  2. Switch to the main branch:

    git checkout main

  3. Cherry-pick the commit:

    git cherry-pick abc123

  4. If there are conflicts, resolve them and continue:

    # Resolve conflicts in your editor, then:
git add .
git cherry-pick --continue

Common Mistakes and Tips

  • Conflicts: Cherry-picking can lead to conflicts, especially if the codebase has diverged significantly. Always review and test the changes after cherry-picking.
  • Multiple Commits: You can cherry-pick multiple commits by specifying a range of commits or using multiple commit hashes.
  • Avoid Overuse: Cherry-picking should be used sparingly. Overuse can lead to a fragmented commit history and make it harder to track changes.

Exercises

Exercise 1: Basic Cherry-Picking

  1. Create a new branch feature-branch from main.
  2. Make a commit in feature-branch.
  3. Switch back to main and cherry-pick the commit from feature-branch.

Solution

# Step 1: Create a new branch and switch to it
git checkout -b feature-branch

# Step 2: Make a commit
echo "Feature work" > feature.txt
git add feature.txt
git commit -m "Add feature work"

# Step 3: Switch back to main
git checkout main

# Step 4: Cherry-pick the commit
git cherry-pick <commit-hash>

Exercise 2: Resolving Conflicts

  1. Create a conflict by making changes to the same file in both main and feature-branch.
  2. Cherry-pick the commit from feature-branch to main and resolve the conflict.

Solution

# Step 1: Create a conflict
# In main branch
echo "Main branch work" > conflict.txt
git add conflict.txt
git commit -m "Add main branch work"

# In feature-branch
git checkout feature-branch
echo "Feature branch work" > conflict.txt
git add conflict.txt
git commit -m "Add feature branch work"

# Step 2: Cherry-pick and resolve conflict
git checkout main
git cherry-pick <commit-hash>

# Resolve conflict in conflict.txt
# Add resolved file
git add conflict.txt
git cherry-pick --continue

Conclusion

Cherry-picking is a powerful tool in Git that allows you to selectively apply changes from one branch to another. While it can be very useful, it should be used judiciously to avoid complicating your commit history. Practice cherry-picking with the exercises provided to become more comfortable with this feature.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved