Skip to content

git rebase

Jump to bottom
ghdrako edited this page Dec 13, 2022 · 5 revisions

Rebase the feature branch onto the master branch using the following commands.

$ git checkout feature
$ git rebase master

# or shorter

git rebase master feature # nie trzeba sie  chekoutowac

This moves the entire feature branch on top of the master branch. It does this by re-writing the project history by creating brand new commits for each commit in the original (feature) branch.

---c1(main)---c2-----c3(*,another)
git rebase another main
---c1------c2-----c3(*,another,main)

Git rebase - changes the base of the branch.

Base of a brancha - the latest commit which is in common with the branch and its parent branch.

git rebase <target branch>

This command rebases the current branch onto the target branch. This means the current branch is now based on the last commit on the target branch. Consequently, the git commit-graph will look like the branch never separated from the original branch, and the commits were based on the current base.

$ git checkout feature
$ git rebase master  # git rebase <target branch>

git rebase actually does is:

  • Relocates the branch head pointer to the target branch pointer. (feature now points to the master)
  • Makes new duplicate commits on the branch. These commits are essentially the same have the same code changes as the original commits, but have different SHA1 values.
  • The older commits are still present on the graph in a detached state.

git rebase --onto

git rebase --onto <newparent> <oldparent>

      Before                           After
    A---B---C---F---G (branch)        A---B---C---F---G (branch)
             \                                     \
              D---E---H---I (HEAD)                  E---H---I (HEAD)

git rebase --onto F D

Rebase the commit reachable from HEAD whose parent is D (so E) on top of F. In other words, change the parent of E from D to F. The syntax of git rebase --onto is then git rebase --onto <newparent> <oldparent>.

Another scenario where this comes in handy is when you want to quickly remove some commits from the current branch without having to do an interactive rebase:

          Before                       After
    A---B---C---E---F (HEAD)        A---B---F (HEAD)

git rebase --onto B E

In this example, in order to remove C and E from the sequence you would say git rebase --onto B E, or rebase HEAD on top of B where the old parent was E.

  1. git rebase --onto with 3 arguments
git rebase --onto <newparent> <oldparent> <until>

Allows you to rebase an arbitrary range of commits on top of another one.

          Before                                     After
    A---B---C---F---G (branch)                A---B---C---F---G (branch)
             \                                             \
              D---E---H---I (HEAD)                          E---H (HEAD)

git rebase --onto F D H

In this case, we want to rebase the exact range E---H on top of F, ignoring where HEAD is currently pointing to. We can do that by saying git rebase --onto F D H, which means:

Rebase the range of commits whose parent is D up to H on top of F.

The syntax of git rebase --onto with a range of commits then becomes git rebase --onto . The trick here is remembering that the commit referenced by is included in the range and will become the new HEAD after the rebase is complete.

Test

Clone this wiki locally