The best answers to the question “When do you use Git rebase instead of Git merge?” in the category Dev.
When is it recommended to use Git rebase vs. Git merge?
Do I still need to merge after a successful rebase?
It’s simple. With rebase you say to use another branch as the new base for your work.
If you have, for example, a branch
master, you create a branch to implement a new feature, and say you name it
cool-feature, of course, the master branch is the base for your new feature.
Now, at a certain point, you want to add the new feature you implemented in the
master branch. You could just switch to
master and merge the
$ git checkout master $ git merge cool-feature
But this way a new dummy commit is added. If you want to avoid spaghetti-history you can rebase:
$ git checkout cool-feature $ git rebase master
And then merge it in
$ git checkout master $ git merge cool-feature
This time, since the topic branch has the same commits of master plus the commits with the new feature, the merge will be just a fast-forward.
- Merge takes all the changes in one branch and merges them into another branch in one commit.
- Rebase says I want the point at which I branched to move to a new starting point
So when do you use either one?
- Let’s say you have created a branch for the purpose of developing a single feature. When you want to bring those changes back to master, you probably want merge (you don’t care about maintaining all of the interim commits).
- A second scenario would be if you started doing some development and then another developer made an unrelated change. You probably want to pull and then rebase to base your changes from the current version from the repository.
To complement my own answer mentioned by TSamper,
a rebase is quite often a good idea to do before a merge, because the idea is that you integrate in your branch
Ythe work of the branch
Bupon which you will merge.
But again, before merging, you resolve any conflict in your branch (i.e.: “rebase”, as in “replay my work in my branch starting from a recent point from the branch
If done correctly, the subsequent merge from your branch to branch
Bcan be fast-forward.
a merge directly impacts the destination branch
B, which means the merges better be trivial, otherwise that branch
Bcan be long to get back to a stable state (time for you solve all the conflicts)
the point of merging after a rebase?
In the case that I describe, I rebase
B onto my branch, just to have the opportunity to replay my work from a more recent point from
B, but while staying into my branch.
In this case, a merge is still needed to bring my “replayed” work onto
The other scenario (described in Git Ready for instance), is to bring your work directly in
B through a rebase (which does conserve all your nice commits, or even give you the opportunity to re-order them through an interactive rebase).
In that case (where you rebase while being in the B branch), you are right: no further merge is needed:
A Git tree at default when we have not merged nor rebased
we get by rebasing:
That second scenario is all about: how do I get new-feature back into master.
My point, by describing the first rebase scenario, is to remind everyone that a rebase can also be used as a preliminary step to that (that being “get new-feature back into master”).
You can use rebase to first bring master “in” the new-feature branch: the rebase will replay new-feature commits from the
HEAD master, but still in the new-feature branch, effectively moving your branch starting point from an old master commit to
That allows you to resolve any conflicts in your branch (meaning, in isolation, while allowing master to continue to evolve in parallel if your conflict resolution stage takes too long).
Then you can switch to master and merge
new-feature (or rebase
master if you want to preserve commits done in your
- “rebase vs. merge” can be viewed as two ways to import a work on, say,
- But “rebase then merge” can be a valid workflow to first resolve conflict in isolation, then bring back your work.
If you have any doubt, use merge.
The only differences between a rebase and a merge are:
- The resulting tree structure of the history (generally only noticeable when looking at a commit graph) is different (one will have branches, the other won’t).
- Merge will generally create an extra commit (e.g. node in the tree).
- Merge and rebase will handle conflicts differently. Rebase will present conflicts one commit at a time where merge will present them all at once.
So the short answer is to pick rebase or merge based on what you want your history to look like.
There are a few factors you should consider when choosing which operation to use.
Is the branch you are getting changes from shared with other developers outside your team (e.g. open source, public)?
If so, don’t rebase. Rebase destroys the branch and those developers will have broken/inconsistent repositories unless they use
git pull --rebase. This is a good way to upset other developers quickly.
How skilled is your development team?
Rebase is a destructive operation. That means, if you do not apply it correctly, you could lose committed work and/or break the consistency of other developer’s repositories.
I’ve worked on teams where the developers all came from a time when companies could afford dedicated staff to deal with branching and merging. Those developers don’t know much about Git and don’t want to know much. In these teams I wouldn’t risk recommending rebasing for any reason.
Does the branch itself represent useful information
Some teams use the branch-per-feature model where each branch represents a feature (or bugfix, or sub-feature, etc.) In this model the branch helps identify sets of related commits. For example, one can quickly revert a feature by reverting the merge of that branch (to be fair, this is a rare operation). Or diff a feature by comparing two branches (more common). Rebase would destroy the branch and this would not be straightforward.
I’ve also worked on teams that used the branch-per-developer model (we’ve all been there). In this case the branch itself doesn’t convey any additional information (the commit already has the author). There would be no harm in rebasing.
Might you want to revert the merge for any reason?
Reverting (as in undoing) a rebase is considerably difficult and/or impossible (if the rebase had conflicts) compared to reverting a merge. If you think there is a chance you will want to revert then use merge.
Do you work on a team? If so, are you willing to take an all or nothing approach on this branch?
Rebase operations need to be pulled with a corresponding
git pull --rebase. If you are working by yourself you may be able to remember which you should use at the appropriate time. If you are working on a team this will be very difficult to coordinate. This is why most rebase workflows recommend using rebase for all merges (and
git pull --rebase for all pulls).
Merge destroys history (squashes commits)
Assuming you have the following merge:
B -- C / \ A--------D
Some people will state that the merge “destroys” the commit history because if you were to look at the log of only the master branch (A — D) you would miss the important commit messages contained in B and C.
If this were true we wouldn’t have questions like this. Basically, you will see B and C unless you explicitly ask not to see them (using –first-parent). This is very easy to try for yourself.
Rebase allows for safer/simpler merges
The two approaches merge differently, but it is not clear that one is always better than the other and it may depend on the developer workflow. For example, if a developer tends to commit regularly (e.g. maybe they commit twice a day as they transition from work to home) then there could be a lot of commits for a given branch. Many of those commits might not look anything like the final product (I tend to refactor my approach once or twice per feature). If someone else was working on a related area of code and they tried to rebase my changes it could be a fairly tedious operation.
Rebase is cooler / sexier / more professional
If you like to alias
rm -rf to “save time” then maybe rebase is for you.
My Two Cents
I always think that someday I will come across a scenario where Git rebase is the awesome tool that solves the problem. Much like I think I will come across a scenario where Git reflog is an awesome tool that solves my problem. I have worked with Git for over five years now. It hasn’t happened.
Messy histories have never really been a problem for me. I don’t ever just read my commit history like an exciting novel. A majority of the time I need a history I am going to use Git blame or Git bisect anyway. In that case, having the merge commit is actually useful to me, because if the merge introduced the issue, that is meaningful information to me.
I feel obligated to mention that I have personally softened on using rebase although my general advice still stands. I have recently been interacting a lot with the Angular 2 Material project. They have used rebase to keep a very clean commit history. This has allowed me to very easily see what commit fixed a given defect and whether or not that commit was included in a release. It serves as a great example of using rebase correctly.