Bird
Raised Fist0
Gitdevops~5 mins

Fast-forward merge in Git - Commands & Configuration

Choose your learning style10 modes available
LearnWhyDeepVisualTryChallengeProjectRecallTime

Start learning this pattern below

Jump into concepts and practice - no test required

or
Recommended
Test this pattern10 questions across easy, medium, and hard to know if this pattern is strong
Introduction
When you work on a feature branch and want to add your changes back to the main branch, a fast-forward merge moves the main branch pointer forward without creating a new commit. This keeps the history simple and linear.
When your feature branch is directly ahead of the main branch with no new commits on main.
When you want to keep the commit history clean and linear without extra merge commits.
When you finished a small fix or feature and want to quickly update the main branch.
When you want to avoid unnecessary merge commits that clutter the history.
When you want to update your local main branch to match the remote after pulling.
Commands
Switch to the main branch where you want to merge the changes.
Terminal
git checkout main
Expected OutputExpected
Switched to branch 'main'
Merge the feature-branch into main. If main has no new commits, this will perform a fast-forward merge moving main forward.
Terminal
git merge feature-branch
Expected OutputExpected
Updating 1a2b3c4..5d6e7f8 Fast-forward file.txt | 2 ++ 1 file changed, 2 insertions(+)
Show the recent commit history with a graph to verify the fast-forward merge happened and history is linear.
Terminal
git log --oneline --graph --decorate -5
Expected OutputExpected
* 5d6e7f8 (HEAD -> main) Add new feature * 1a2b3c4 Initial commit
Key Concept

If the main branch has no new commits, merging a feature branch just moves the main pointer forward without creating a new merge commit.

Common Mistakes
Trying to fast-forward merge when the main branch has new commits.
Git cannot fast-forward because the histories have diverged, so it creates a merge commit instead.
Either rebase your feature branch onto main before merging or accept the merge commit.
Not switching to the main branch before merging.
Merging from the wrong branch will not update main and can cause confusion.
Always checkout the branch you want to update before running git merge.
Summary
Switch to the main branch with git checkout main.
Run git merge feature-branch to merge changes; if possible, this will fast-forward main.
Use git log --oneline --graph to verify the merge was fast-forward and history is linear.

Practice

(1/5)
1. What happens during a fast-forward merge in Git?
easy
A. The source branch is deleted automatically.
B. A new merge commit is always created.
C. The branch pointer moves forward without creating a new commit.
D. The commit history becomes non-linear.

Solution

  1. Step 1: Understand fast-forward merge behavior

    A fast-forward merge moves the branch pointer forward to the latest commit of the source branch without creating a new merge commit.

  2. Step 2: Compare with other merge types

    Unlike a normal merge, it does not create a new commit and keeps history linear.

  3. Final Answer:

    The branch pointer moves forward without creating a new commit. -> Option C

  4. Quick Check:

    Fast-forward merge = pointer moves forward [OK]
Hint: Fast-forward means no new commit, just pointer moves [OK]
Common Mistakes:
  • Thinking a merge commit is always created
  • Assuming source branch deletes automatically
  • Believing history becomes non-linear
2. Which Git command syntax performs a fast-forward merge of branch feature into main only if possible, otherwise aborts?
easy
A. git merge --squash feature
B. git merge feature
C. git merge --no-ff feature
D. git merge --ff-only feature

Solution

  1. Step 1: Identify command for fast-forward only

    The option --ff-only tells Git to merge only if it can fast-forward, otherwise it aborts.

  2. Step 2: Compare other options

    --no-ff disables fast-forward, --squash creates a single commit without merging, and plain git merge feature may create a merge commit.

  3. Final Answer:

    git merge --ff-only feature -> Option D

  4. Quick Check:

    Fast-forward only = --ff-only [OK]
Hint: Use --ff-only to ensure only fast-forward merges happen [OK]
Common Mistakes:
  • Using --no-ff disables fast-forward merges
  • Assuming plain merge always fast-forwards
  • Confusing --squash with fast-forward
3. Given the following Git commands, what is the output of git log --oneline main after merging?
git checkout main
# main points to commit A

git checkout -b feature
# feature branch created from A

git commit --allow-empty -m "Add feature commit"
# feature now points to commit B

git checkout main

git merge feature
medium
A. B
B. B\nA
C. A
D. Merge commit with A and B

Solution

  1. Step 1: Understand branch states before merge

    Main points to commit A. Feature branch adds commit B on top of A.

  2. Step 2: Analyze merge behavior

    Since main has no new commits after branching, merging feature into main will fast-forward main to B.

  3. Final Answer:

    B\nA -> Option B

  4. Quick Check:

    Fast-forward merge moves main to B [OK]
Hint: If main unchanged, merge moves pointer to feature commit [OK]
Common Mistakes:
  • Expecting merge commit creation
  • Thinking main stays at A
  • Confusing commit hashes output
4. You tried to fast-forward merge branch feature into main using git merge --ff-only feature, but Git returned an error. What is the most likely cause?
medium
A. The main branch has new commits not in feature.
B. The feature branch is behind main.
C. The feature branch has no commits.
D. You forgot to commit changes on feature branch.

Solution

  1. Step 1: Understand --ff-only error cause

    The --ff-only option fails if a fast-forward merge is not possible.

  2. Step 2: Identify when fast-forward is impossible

    If main has new commits not in feature, Git cannot fast-forward main to feature, causing the error.

  3. Final Answer:

    The main branch has new commits not in feature. -> Option A

  4. Quick Check:

    Fast-forward fails if main has new commits [OK]
Hint: Fast-forward fails if main moved ahead since branching [OK]
Common Mistakes:
  • Assuming feature must be behind main
  • Thinking empty feature branch causes error
  • Confusing uncommitted changes with merge errors
5. You have a main branch and a feature branch. Both have new commits since branching. You want to merge feature into main but keep history linear without merge commits. Which approach is best?
hard
A. Use git rebase main on feature, then fast-forward merge.
B. Use git merge --no-ff feature to force a merge commit.
C. Use git merge --ff-only feature and abort if not fast-forward.
D. Delete main and rename feature to main.

Solution

  1. Step 1: Understand the problem with fast-forward

    Since both branches have new commits, a fast-forward merge is not possible directly.

  2. Step 2: Use rebase to linearize history

    Rebasing feature onto main moves feature commits on top of main, enabling a fast-forward merge afterward.

  3. Step 3: Perform fast-forward merge after rebase

    After rebase, merging feature into main will be a fast-forward, keeping history linear without merge commits.

  4. Final Answer:

    Use git rebase main on feature, then fast-forward merge. -> Option A

  5. Quick Check:

    Rebase then merge = linear history [OK]
Hint: Rebase feature on main to enable fast-forward merge [OK]
Common Mistakes:
  • Trying --ff-only merge when not possible
  • Forcing merge commit breaks linear history
  • Deleting branches unnecessarily