Introduction Git Merge vs Rebase
Two common Git workflows to integrate changes between branches are merging and rebasing. While both combine changes, there are fundamental differences between Git merge and rebase. In this guide, we will understand how merge and rebase work in Git and illustrate their usage with examples.
How Git Merge Works
git merge command lets you integrate changes from a source branch into a target branch. For example, merging feature branch changes into main:
git checkout main git merge feature
This creates a new “merge commit” in main that combines the feature branch changes:
A---B---C main / D---E---F---G feature git merge feature A---B---C---M main / / D---E---F---G---/ feature
The resulting merge commit
M includes changes from both branches.
Git handles merges intelligently based on commit relationships between branches:
Fast-forward merge – If target branch contains no commits after the merge point, the source branch HEAD is simply moved forward:
A---B---C---D main \ E---F---G feature git checkout main git merge feature A---B---C---D---E---F---G main \ feature
3-way merge – If both branches have diverged, their snapshots are combined and a merge commit is created:
A---B---X main / C---D---E---F---G feature git checkout main git merge feature A---B---X---M main / / C---D---E---F---G-------/ feature
This replayability of commits makes Git history branching interaction explicit.
How Git Rebase Works
Rebasing essentially replays a branch’s commits on top of another specified base branch. For example, rebasing feature onto main:
A---B---C main \ D---E---F feature git checkout feature git rebase main A---B---C main / D'--E'--F' feature
This moves the entire feature branch to begin on top of main, creating new commits D’, E’, F’.
How Rebase Works
Rebase replays commits from the current branch individually on top of the specified base branch:
- Checkout the
- Find the common ancestor between
- Replay each commit after A from
featureon top of
- Apply D atop main and create D’
- Apply E atop D’ and create E’
- Apply F atop E’ and create F’
featureto point to F’
This can cause conflicts if the replayed commits cannot be cleanly applied atop the base branch.
Key Differences Between Merge and Rebase
|Process||Creates merge commit||Replays commits|
|Main branch||Linear history||Linear history|
|Feature branches||Contains merges||Rebased onto main|
|Conflicts||At merge time||During rebase|
Merging preserves complete history whereas rebasing rewrites history.
When to Use Merge or Rebase
Use merge when:
- You want to integrate upstream changes into your feature branch.
- You need a clean project history.
- Multiple developers are collaborating on the branch.
Use rebase when:
- You want a linear project history without unnecessary merges.
- You work alone on the feature branch most of the time.
- The branch is still private and unpushed to remote.
Rebasing rewrites history so avoid it on public branches that others may depend on.
Frequently Asked Questions
1. What happens in a git merge vs rebase?
Merge creates a merge commit while rebase replays commits onto another base branch.
2. When should you use rebase over merge?
If you need a linear project history, rebase locally before pushing your feature branch.
3. Does rebasing rewrite commit history?
Yes, rebasing changes commit SHAs so avoid it on public branches.
4. What is the golden rule of rebasing?
Never rebase commits that have been shared publicly.
5. How do you abort a rebase?
git rebase --abort to abort an ongoing rebase process and restore original state.
git mergeintegrates branches by creating merge commits.
git rebasereplays commits from one branch onto another.
- Merging preserves history while rebasing rewrites it.
- Understand the difference between the two workflows.
- Leverage both merge and rebase as suitable for the situation.
Mastering merging and rebasing gives greater flexibility in integrating changes between branches.