Git Merge Explained: Examples, Fast-Forward & Conflict Resolution Guide

Git merge is one of the most commonly used commands to combine changes from different branches created using git branch basics. Whether you're integrating feature work, resolving conflicts, or understanding fast-forward merges, knowing the right commands is essential. This guide covers all key Git merge scenarios with practical examples and a quick cheat sheet.

Git Merge Commands - Quick Cheat Sheet

What is Git Merge?

Git merge is used to combine changes from one branch into another, typically integrating feature work into the main branch. It preserves the history of both branches and creates a unified commit history. This is a core operation in Git workflows, especially in collaborative development as part of a complete Git workflow.

What does git merge do

The git merge command takes changes from a specified branch and integrates them into your current branch.

git merge feature-branch

This command:

• Combines commit history from both branches
• Creates a new merge commit (in most cases)
• Updates the current branch with merged changes

When to use git merge vs rebase

• Use git merge when you want to preserve complete branch history
• Use git rebase when you want a clean, linear history using git rebase

Example:

git merge feature-branch
git rebase feature-branch

Key difference:

• Merge → keeps history intact
• Rebase → rewrites history

How git merge works internally

Git identifies a common ancestor (base commit) between branches and applies changes accordingly, which you can inspect using git log.

There are two main ways Git performs a merge:

• Fast-forward merge
• Three-way merge

Git compares:

• Base commit
• Source branch changes
• Target branch changes

Then it combines them into a single branch state.

Basic Git Merge Example

Merge feature branch into main

Switch to the target branch using git checkout:

git checkout main

Merge the feature branch:

git merge feature-branch

Step-by-step git merge workflow

git checkout main
git fetch --all
git pull
git merge feature-branch

This ensures your branch is updated using git fetch and ready for merging.

• You are on the correct branch
• Your branch is updated
• Merge happens without conflicts (if possible)

Verify merge results

Check the status:

git status

View commit history:

git log --oneline --graph

If successful, you will see the merged commits reflected in your history.

Fast-Forward vs Three-Way Merge

What is fast-forward merge

A fast-forward merge happens when there are no new commits in the target branch.

git merge feature-branch

Git simply moves the pointer forward without creating a new commit.

When fast-forward merge happens

• No divergence between branches
• Feature branch is ahead of main
• No additional commits in main after branching

Result:

• Clean linear history
• No merge commit

What is three-way merge

A three-way merge occurs when both branches have diverged.

Git uses:

• Common ancestor
• Source branch commit
• Target branch commit

Example:

git merge feature-branch

Git creates a new merge commit combining both histories.

Differences between fast-forward and no-fast-forward

To force no-fast-forward:

git merge --no-ff feature-branch

This ensures a merge commit is always created, preserving branch history.

Merge Branch with --no-ff

Using --no-ff ensures that Git always creates a merge commit, even if a fast-forward merge is possible. This helps preserve branch history and makes it easier to track feature development.

Why use --no-ff merge

By default, Git performs a fast-forward merge when possible. However, this can hide the context of feature branches.

Using:

git merge --no-ff feature-branch

ensures:

• A merge commit is always created
• Branch history remains visible
• Easier tracking of feature work

Preserve branch history

Without --no-ff, Git may flatten history:

main → A → B → C

With --no-ff, history is preserved:

main → A → B → C
          \       \
           D → E → M (merge commit)

This is useful in team environments where understanding changes is important.

Example with real workflow

git checkout main
git pull
git merge --no-ff feature-login -m "Merge feature-login into main"

This creates a clear merge commit with a descriptive message.

Handle Merge Conflicts (Real-World Case)

Why conflicts occur during merge

Conflicts happen when:

• Same file is modified in both branches
• One branch deletes a file while another modifies it
• Conflicts happen when changes overlap, which you can analyze using git diff.

Identify conflict using git status

Run:

git status

You will see:

both modified: file.txt

Git marks conflicting sections inside files using:

<<<<<<< HEAD
=======
>>>>>>> feature-branch

Resolve conflict step-by-step

1. Open the conflicting file
2. Manually resolve differences
3. Remove conflict markers
4. Stage the file using git add:

git add file.txt

5. Complete the merge using git commit:

git commit

Useful commands to fix conflicts

git merge --abort      # Cancel merge
git diff               # View differences
git log --merge        # View conflicting commits
git checkout --ours    # Keep current branch changes
git checkout --theirs  # Accept incoming changes

Merge Specific Commits and Advanced Usage

Merge a specific commit

To merge a specific commit:

git merge <commit-hash>

Useful when you want only selected changes instead of full branch merge, similar to git cherry pick.

Merge multiple branches

You can merge multiple branches at once:

git merge branch1 branch2

Git will combine all specified branches into the current branch.

Squash merge vs normal merge

Squash merge combines all commits into a single commit:

git merge --squash feature-branch
git commit

Difference:

Use git merge strategies

Git supports different merge strategies:

git merge -s recursive feature-branch
git merge -s ours feature-branch
git merge -X theirs feature-branch

Common strategies:

• recursive → default strategy
• ours → keep current branch changes
• theirs → prefer incoming branch changes

Git Merge vs Git Rebase

Key differences

When to use merge vs rebase

• Use merge for team collaboration and shared branches
• Use rebase for cleaner commit history before pushing

Pros and cons

Git Merge

• ✔ Preserves history
• ✔ Safe for shared branches
• ✖ Can create messy history

Git Rebase

• ✔ Cleaner linear history
• ✔ Easier to read logs
• ✖ Rewrites history (risk in shared repos)

Summary

Git merge is essential for combining changes from different branches and managing collaborative workflows along with concepts explained in merge vs rebase. Whether you are performing a simple merge, handling conflicts, or using advanced strategies like squash or no-fast-forward, understanding these concepts helps maintain a clean and reliable project history.

Choosing between merge and rebase depends on your workflow, but mastering both ensures flexibility and better version control practices.

Official Documentation

• Git Merge Documentation
• Git Rebase Documentation
• Git Diff Documentation