What 's the difference between 'git merge' and 'git rebase'?

When using version control systems like git to manage the source code of a project, git merge and git rebase are two common methods for integrating changes from different branches. Their primary purpose is to combine changes from two branches into a unified history, but they differ in their approach and impact on the commit history.

git merge

git merge is a straightforward method for merging changes. It takes the latest commits of two branches and their common ancestor, then attempts to automatically merge these changes. If different branches modify the same part of the same file, conflicts may arise, requiring manual resolution.

After merging, git creates a new 'merge commit' with two parent commits, representing the state of the two branches before merging. This approach preserves a complete, non-linear project history, providing clear visibility into how the project evolved over time, including all branches and merge points.

git rebase

The main idea of git rebase is to take a series of commits and reapply them sequentially on top of another branch. This process aims to make changes from one branch appear as if they were made directly on another branch, resulting in a linear history.

Specifically, suppose you are developing on a feature branch that diverged from the master branch. As you work on the feature branch, master may have new commits. In this case, you can use git rebase to reapply your feature branch changes on top of the current tip of the master branch (HEAD). This results in your feature branch commits appearing after master's commits, creating a linear history.

Comparison

• History Clarity: git merge preserves a non-linear history, showing all branches and merge points. git rebase creates a linear history.
• Conflict Handling: In git rebase, conflicts may occur during each commit application, requiring individual resolution. In git merge, conflicts are resolved only once at the final merge.
• Recommended Use Cases: git merge is typically used for merging public or shared branches (e.g., merging a completed feature branch back into master or develop). git rebase is commonly used in personal development, such as merging the latest master changes into your feature branch to avoid complex merges later.

Example

Assume I am developing a new feature on the feature branch. Meanwhile, my colleague advances some changes on the master branch. To keep my branch updated, I can choose:

1. Using git merge:

bash
 git checkout feature
 git merge master

This creates a new merge commit on my feature branch.

1. Using git rebase:

bash
 git checkout feature
 git rebase master

This reapplies all changes from my feature branch on top of the latest changes in the master branch.

Overall, the choice depends on the desired project history and your personal or team workflow.