Comprehensive Guide to Git Rebase: Rebasing One Branch on Top of Another

Introduction

In distributed version control systems, Git's rebase operation is a crucial tool for managing branch history. This article delves into a practical development scenario, analyzing how to rebase the Branch2 branch onto the latest commits of Branch1, ensuring smooth integration of code changes.

Branch Structure Analysis

The initial branch structure is depicted as follows:

Master---
         \
          Branch1--commit1--commit2
                                   \
                                    Branch2 (local branch)

After modifications by another developer, the Branch1 branch has changed: commits were squashed and new commits were added, resulting in the structure:

Master---
         \
          Branch1--squashed commit1,2--commit3--commit4
                                       \
                                        Branch2 (local branch)

At this point, Branch2 is based on an old commit of Branch1 and needs to be rebased onto the latest Branch1 commits to incorporate the most recent changes.

Detailed Operation Steps

Step 1: Commit Local Changes

Before performing the rebase operation, any uncommitted local changes must be committed to the repository:

git add .
git commit -m "Describe local changes"

This ensures all modifications are recorded in the commit history, providing a foundation for the subsequent rebase.

Step 2: Create a Branch Backup

To prevent data loss due to operational errors, it is highly recommended to create a branch backup:

git checkout -b Branch2_backup

This command creates a new branch Branch2_backup based on the current Branch2, preserving the original state for potential recovery.

Step 3: Update Remote Branch Information

Before executing the rebase, the latest state of the remote repository must be fetched:

git fetch origin

This command updates all tracking branches, including Branch1, ensuring the local repository is aware of the latest commits on remote Branch1.

Step 4: Execute the Rebase Operation

Rebase the Branch2 branch onto origin/Branch1:

git rebase origin/Branch1

This operation reapplies the unique commits of Branch2 on top of the latest commits of Branch1, generating a new commit history.

Step 5: Handle Conflicts

If conflicts arise during the rebase, they must be resolved manually:

1. Edit the conflicting files to merge content
2. Use git add <file> to mark conflicts as resolved
3. Execute git rebase --continue to proceed with the rebase

Repeat these steps until all conflicts are resolved.

Step 6: Push Changes to the Remote Repository

Since the rebase operation rewrites the commit history, a force push to the remote repository is required:

git push --force origin Branch2

Force pushing overwrites the remote branch history, so it should be done cautiously to avoid impacting other collaborators.

Operation Result Analysis

After a successful rebase, the branch structure becomes:

Master --
         \
          Branch1--commit3--commit4--Branch2'

Here, Branch2' denotes the Branch2 branch rebased onto Branch1, with all unique commits rewritten.

Important Considerations

• History Rewriting Risks: Rebase alters commit history; use with caution on published branches
• Collaboration Impact: Force pushing can disrupt other developers' local branches; communicate in advance
• Backup Necessity: Creating a backup branch before operation is key to preventing data loss

Conclusion

Git rebase is a powerful branch management tool that enables a clean, linear commit history. By following the steps outlined in this article, developers can safely rebase one branch onto another, effectively integrating code changes. Mastering key aspects such as backup creation, conflict resolution, and force pushing significantly enhances team collaboration efficiency.