Merging Branches (git merge)

Integrating separate lines of development, typically found on different branches, back into a main branch like main or master is a common objective in collaborative projects. This process of combining the history and changes from various branches is called merging. Git provides the git merge command specifically for this purpose.

Merging takes the changes from a source branch (e.g., your feature branch) and integrates them with the history of a target branch (e.g., the main branch). Git is remarkably good at figuring out how to combine these changes automatically.

The git merge Command

To perform a merge, you first need to switch to the branch that you want to merge into. This is typically your main line of development, such as the main branch. Once you are on the target branch, you use the git merge command, specifying the name of the branch you want to merge from.

For example, if you have finished work on a branch named new-feature and want to integrate those changes into your main branch, you would run the following commands:

1. Switch to the target branch (main):

   git switch main
   

   Or, using the older command:

   git checkout main
   

2. Merge the source branch (new-feature) into the current branch (main):

   git merge new-feature
   

How Merging Works

When you execute git merge, Git performs several steps behind the scenes:

1. Identify Bases: Git looks back in the history of both branches (the current one and the one you're merging in) to find the best common ancestor commit. This is the point where the two branches originally diverged.
2. Calculate Changes: Git determines the changes made on each branch since that common ancestor.
3. Combine Changes: It attempts to combine these sets of changes.

If the changes occurred in different parts of the files or in different files altogether, Git can often combine them automatically without any issues.

The Merge Commit

Often, when changes have occurred on both branches since they diverged, Git will create a new, special commit called a merge commit. This commit acts as a unification point in the project history. Its defining characteristic is that it has more than one parent commit: one pointing to the tip of the branch you were on (e.g., main), and another pointing to the tip of the branch you merged in (e.g., new-feature).

This merge commit doesn't introduce new file changes itself (unless conflicts needed resolving), but rather serves as a record that the histories of the two branches were combined at this point.

A merge commit (M) combines work from two parent commits (B on the main branch, D on the new-feature branch), integrating the divergent histories. The main label now points to M.

After running git merge new-feature while on main, Git might output messages indicating the files that were changed and confirming the creation of the merge commit (if one was necessary). Your main branch now incorporates all the work done on the new-feature branch.

Merging is a fundamental operation for integrating work in Git. While it often works smoothly, sometimes Git encounters situations where changes on the merging branches conflict with each other. We will discuss how Git handles simpler merge scenarios (fast-forward merges) and how to resolve conflicts in the following sections.