Merging is a safe option that preserves the entire history of your repository, while rebasing creates a linear history by moving your feature branch onto the tip of main .
Git Fetch is the command that tells the local repository that there are changes available in the remote repository without bringing the changes into the local repository. Git Pull on the other hand brings the copy of the remote directory changes into the local repository.
Git merge combines changes into one consistent tree, just one part of what Git pull does. Remember, Git pull requests entail combining the changes into one tree and downloading the source code as well.
Regarding your question: git rebase rebases the branch you want. git pull --rebase performs a fetch + rebase in the branches you pull.
fetch
will download any changes from the remote* branch, updating your repository data, but leaving your local* branch unchanged.
pull
will perform a fetch
and additionally merge
the changes into your local branch.
What's the difference? pull
updates you local branch with changes from the pulled branch. A fetch
does not advance your local branch.
Given the following history:
C---D---E local / A---B---F---G remote
merge
joins two development histories together. It does this by replaying the changes that occurred on your local branch after it diverged on top of the remote branch, and record the result in a new commit. This operation preserves the ancestry of each commit.
The effect of a merge
will be:
C---D---E local / \ A---B---F---G---H remote
rebase
will take commits that exist in your local branch and re-apply them on top of the remote branch. This operation re-writes the ancestors of your local commits.
The effect of a rebase
will be:
C'--D'--E' local / A---B---F---G remote
What's the difference? A merge
does not change the ancestry of commits. A rebase
rewrites the ancestry of your local commits.
*
This explanation assumes that the current branch is a local branch, and that the branch specified as the argument to fetch
, pull
, merge
, or rebase
is a remote branch. This is the usual case. pull
, for example, will download any changes from the specified branch, update your repository and merge
the changes into the current branch.
Fetch vs Pull
Git fetch just updates your repo data, but a git pull will basically perform a fetch and then merge the branch pulled
What is the difference between 'git pull' and 'git fetch'?
Merge vs Rebase
from Atlassian SourceTree Blog, Merge or Rebase:
Merging brings two lines of development together while preserving the ancestry of each commit history.
In contrast, rebasing unifies the lines of development by re-writing changes from the source branch so that they appear as children of the destination branch – effectively pretending that those commits were written on top of the destination branch all along.
Also, check out Learn Git Branching, which is a nice game that has just been posted to HackerNews (link to post) and teaches a lot of branching and merging tricks. I believe it will be very helpful in this matter.
pull vs fetch:
The way I understand this, is that git pull
is simply a git fetch
followed by git merge
. I.e. you fetch the changes from a remote branch and then merge it into the current branch.
merge vs rebase:
A merge will do as the command says; merge the differences between current branch and the specified branch (into the current branch). I.e. the command git merge another_branch
will the merge another_branch
into the current branch.
A rebase works a bit differently and is kind of cool. Let's say you perform the command git rebase another_branch
. Git will first find the latest common version between the current branch and another_branch
. I.e. the point before the branches diverged. Then git will move this divergent point to the head of the another_branch
. Finally, all the commits in the current branch since the original divergent point are replayed from the new divergent point. This creates a very clean history, with fewer branches and merges.
However, it is not without pitfalls! Since the version history is "rewritten", you should only do this if the commits only exists in your local git repo. That is: Never do this if you have pushed the commits to a remote repo.
The explanation on rebasing given in this online book is quite good, with easy-to-understand illustrations.
pull with rebasing instead of merge
I'm actually using rebase quite a lot, but usually it is in combination with pull:
git pull --rebase
will fetch remote changes and then rebase instead of merge. I.e. it will replay all your local commits from the last time you performed a pull. I find this much cleaner than doing a normal pull with merging, which will create an extra commit with the merges.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With