What is rebase? How to use the rebase command? Let's study how to use the git rebase command.

We know that there are two main methods to integrate modifications from different branches in Git: merge and rebase. In fact, git rebase and git merge do the same thing. They are both designed to merge changes from one branch into another, but in slightly different ways.

merge command example

git checkout feature
git merge master

In this way, the new merge commit in the feature branch connects the history of the two branches together

Merge The good thing is that it is a safe operation. Existing branches will not be changed

The feature branch will introduce an external merge commit every time upstream changes are merged. If the upstream branch is very active, this will more or less pollute your branch history

Rebase command example

git checkout feature
git rebase master

It will move the entire feature branch to the master branch Afterwards, all new commits on the master branch are effectively merged.

However, rebase creates a new commit for each commit on the original branch, rewriting the project history and not merging it. submit.

When rebasing two branches, the generated "replay" does not have to be applied on the target branch. You can also specify another branch for application. You created a feature branch server, added some features to the server, and submitted C3 and C4. Then I created the feature branch client from C3, added some features to the client, and submitted C8 and C9. Finally, you go back to the server branch and commit C10 again.

Suppose you want to merge the changes in the client into the main branch and publish them, but you do not want to merge the changes in the server for the time being, because they still need to be tested more comprehensively. At this time, you can use the --onto option of the git rebase command to select the modifications that are in the client branch but not in the server branch (i.e. C8 and C9), and replay them on the master branch:

$ git rebase --onto master server client

The above command means: "Take out the client branch, find the modifications after the common ancestor of the client branch and the server branch, and then replay them on the master branch." This is a little complicated to understand, but the effect is very cool.

Now you can fast forward the merge master branch.

$ git checkout master
$ git merge client

Next you decide to integrate the changes in the server branch. Use the git rebase [basebranch] [topicbranch] command to directly rebase the feature branch (ie server in this example) to the target branch (ie master). This saves you the multiple steps of first switching to the server branch and then executing the rebase command on it.

$ git rebase master server

Usage scenarios of rebase in development

rebase can be applied more or less in your team’s Git workflow

Local Cleanup

Perform interactive rebase every once in a while, you can ensure that every commit in your feature branch is focused and meaningful. You don’t have to worry about creating orphaned commits when writing code - because you will definitely be able to fix it later

The following command interactively rebases the latest 3 commits:

git checkout feature
git rebase -i HEAD~3

You actually No branch is moved - you just merge the next 3 commits

Interactive rebase is a great way to introduce git rebase into your workflow because it only affects the local branch. Other developers can only see the results of what you've done, which is a very neat, easy-to-track branch history.

But again, this can only be used on private branches. If you work with other developers on the same feature branch, the branch is public and you cannot rewrite the history.

The above is the detailed content of How to use git rebase to merge branches in Git. For more information, please follow other related articles on the PHP Chinese website!