JIYIK CN >

This tutorial shows how to merge branches in Git without using fast-forward.

We work in a collaborative development environment using Git. We create many branches for different purposes, and eventually, we merge these branches into the main branch to provide a release.

We merge branches in Git with or without fast-forward.

We will now illustrate this with an example.

Using the command with and without --no-ffthe (no fast-forward) option in Gitgit merge

In a collaborative development environment, we often create multiple branches in Git to serve different purposes. Then we eventually merge these branches into the main branch to provide a release version.

Sometimes, our mainline branch HEADhas commits that are ancestors of the commits of the branch we are trying to merge in. In this case, the merge is done with a fast-forward.

A fast-forward merge can happen when there is a linear path from the current branch tip to the target branch. Suppose we have branch feature1, and we merge it into our mainline branch main.

Now, suppose that commit mainof branch -i HEADis feature1an ancestor of commit of branch -i, the one we want to merge.

In this case, instead of merging the branches, all Git needs to do to integrate the history is to move (i.e.) fast-forward the current branch tip to the target branch tip.

So, in our example, by fast-forwarding, mainthe current position of the branch HEADwill move up to feature1the branch tip.

mainPlease see the following figure for the situation of branches and before merging feature1.

              E---F---G feature1
             /
A---B---C---D main

Therefore, when we git mergemerge two branches using the command, a fast-forward will occur.

To perform the merge, we execute the command as follows.

$ git merge feature1

After executing the command, mainthe branch will be fast-forwarded.

See the fast forward illustration below.

              E---F---G feature1, main
             /
A---B---C---D

Therefore, mainthe current of branch HEADis now fast-forwarded. No merge commit is created in this case.

Sometimes, we might want to do an actual merge instead of a fast-forward. Suppose we want to maintain our branch topology.

In this case, we can use the command with --no-ffoption git merge.

The command option --no-ffcauses a merge commit to be created in all cases, even if the merge could be resolved as a fast-forward.

So in our case, to do a merge without fast-forwarding, we need to do the following.

$ git merge --no-ff feature1

So now git mergethe command feaure1merges branch into mainbranch and produces a merge commit (even though it is a fast-forward merge).

This is useful for recording all merges that have occurred in a repository.

Therefore, we explain in detail how to merge branches in Git without using fast-forward.