git merge Explained: Fast-Forward, Three-Way, –no-ff and Squash Merges

Merging brings finished work back into main. In this lesson you will learn how Git decides between fast-forward and three-way merges, use the most important merge options, check what will be merged, and clean up afterwards.

---

🔀 What Does Merging Do?

When the work on a branch is finished, you merge it into another branch, usually main. Git combines the histories and the changes. You always merge into the branch you are currently on:

git switch main                 # 1. go to the branch that should receive the changes
git pull                        # 2. make sure it is up to date
git merge feature/login-tests   # 3. bring the feature in

Depending on the history, Git performs one of two kinds of merge.

---

⏩ Fast-Forward Merge

If main has no new commits since the branch was created, Git simply moves the main pointer forward. No merge commit is created.

Before:                              After git merge feature:
C1 ── C2 ← main                      C1 ── C2 ── C3 ── C4 ← main, feature
        \
         C3 ── C4 ← feature

Updating 8b1d4e2..7e2f1a9
Fast-forward
 tests/login.spec.ts | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

---

🔺 Three-Way Merge

If both branches have new commits, Git looks at three snapshots (the common ancestor and the two branch tips) and creates a new merge commit with two parents.

Before:                                After git merge feature:
C1 ── C2 ── C5 ← main                  C1 ── C2 ── C5 ──── M ← main
        \                                      \          /
         C3 ── C4 ← feature                     C3 ── C4 ← feature

Git opens your editor with a default message like “Merge branch ‘feature/login-tests'”; save and close to finish. If both branches changed the same lines, Git stops with a conflict instead; see Resolve Merge Conflicts.

---

🎛️ Merge Options

Command	Result
git merge feature	Fast-forward if possible, otherwise a merge commit
git merge --no-ff feature	Always create a merge commit, keeping the branch visible in history
git merge --ff-only feature	Merge only if a fast-forward is possible; otherwise stop
git merge --squash feature	Combine all branch changes into staged changes; you then make one normal commit
git merge --abort	Cancel a merge that stopped with conflicts and go back to the state before

–no-ff vs –squash

	--no-ff	--squash
Commits from the branch kept in main’s history	✅ All of them	❌ Replaced by one new commit
Merge commit	✅	❌
Readable history of main	Detailed	Compact, one commit per feature
GitHub equivalent	“Create a merge commit”	“Squash and merge”

GitHub’s three pull-request merge buttons (merge commit, squash and merge, rebase and merge) map to these strategies; see Pull Requests Step by Step.

---

🔍 Check Before and After Merging

git log --oneline main..feature/login-tests   # commits that will come in
git diff main...feature/login-tests           # changes on the branch since it split from main
git branch --merged                           # branches already merged into the current branch
git branch --no-merged                        # branches with unmerged work
git log --oneline --graph --all               # see the result

---

🧹 After Merging

git push                              # publish the merged main
git branch -d feature/login-tests     # delete the merged branch locally
git push origin --delete feature/login-tests

---

🧭 Merge vs Rebase (Preview)

Merging preserves history exactly as it happened and is always safe for shared branches. Rebasing rewrites a branch so it looks as if it started from the latest main, giving a linear history. The full comparison is in git rebase and rebase vs merge.

---

📝 Assignment

1. Create feature/a from main, make two commits, switch to main and merge. Confirm it was a fast-forward.
2. Create feature/b, commit on it, then commit something different on main. Merge feature/b and inspect the merge commit with git log --oneline --graph.
3. Repeat with --no-ff on a branch that could fast-forward and compare the graphs.
4. Merge a branch with three commits using --squash and commit the result with one message.
5. Use git branch --merged to find branches you can safely delete, and delete them.

---

❓ FAQ

🤔 How do I merge a branch into main?

Switch to main (git switch main), update it (git pull), then run git merge branch-name and push.

🤔 What is a fast-forward merge?

A merge where the target branch has no new commits, so Git just moves its pointer forward to the branch tip without creating a merge commit.

🤔 What does git merge –no-ff do?

It always creates a merge commit, even when a fast-forward is possible, so the feature branch remains visible in history.

🤔 How do I cancel a merge?

If the merge stopped with conflicts, run git merge --abort. If it already completed and was not pushed, git reset --hard HEAD~1 removes it; if pushed, use git revert -m 1 <merge-commit>.

🤔 What is the difference between merge and squash merge?

A normal merge keeps every commit from the branch. A squash merge combines them into a single new commit on the target branch.

---

🎯 Next Steps

• 🧯 Resolve Merge Conflicts Step by Step
• 🧬 git rebase and Rebase vs Merge
• 📘 Git and GitHub Tutorial: full course