git rebase basic usage - Commands & Configuration

Introduction

Sometimes your work branch falls behind the main branch. Git rebase helps you update your branch by moving your changes on top of the latest main branch commits. This keeps history clean and easy to follow.

When you want to update your feature branch with the latest changes from the main branch before merging.

When you want to keep a linear project history without extra merge commits.

When you want to fix conflicts early by applying your changes on top of updated code.

When you want to clean up your commit history before sharing your branch.

When you want to avoid confusing merge commits in your project timeline.

Commands

Switch to your feature branch where you want to apply the rebase.

Terminal

git checkout feature-branch

Expected Output

Switched to branch 'feature-branch'

Fetch the latest commits from the remote repository to ensure you have the newest main branch updates.

Terminal

git fetch origin

Expected Output

remote: Enumerating objects: 5, done.

remote: Counting objects: 100% (5/5), done.

remote: Compressing objects: 100% (3/3), done.

remote: Total 3 (delta 2), reused 0 (delta 0), pack-reused 0

Unpacking objects: 100% (3/3), 1.23 KiB | 1.23 MiB/s, done.

Reapply your feature branch commits on top of the latest main branch commits fetched from origin. This updates your branch with the newest changes.

Terminal

git rebase origin/main

Expected Output

First, rewinding head to replay your work on top of it...

Applying: Add new feature implementation

Check the status to confirm the rebase completed successfully and your branch is up to date.

Terminal

git status

Expected Output

On branch feature-branch

Your branch is up to date with 'origin/feature-branch'.

nothing to commit, working tree clean

Key Concept

If you remember nothing else from this pattern, remember: git rebase moves your changes on top of the latest main branch commits to keep history clean and updated.

Common Mistakes

Running git rebase without fetching the latest main branch updates first.

Your rebase will not include the newest changes from the main branch, so your branch stays outdated.

Always run git fetch origin before git rebase origin/main to get the latest commits.

Trying to rebase a branch that has already been pushed and shared without coordination.

Rebasing rewrites history, which can confuse others who have the old branch version.

Only rebase local branches or coordinate with your team before rebasing shared branches.

Ignoring conflicts during rebase and not resolving them properly.

Unresolved conflicts stop the rebase process and leave your branch in a broken state.

Carefully resolve conflicts, then run git rebase --continue to finish the rebase.

Summary

Switch to your feature branch with git checkout feature-branch.

Fetch the latest main branch commits using git fetch origin.

Rebase your branch on top of the updated main branch with git rebase origin/main.

Check your branch status after rebase with git status to confirm success.

Practice

1. What does the git rebase command primarily do?

easy

A. Deletes all commits from the current branch

B. Merges two branches together with a merge commit

C. Creates a new branch without any commits

D. Moves your commits to a new base commit to create a linear history

Solution

1. Step 1: Understand the purpose of git rebase

   Git rebase moves commits from one base to another to keep history linear and clean.

2. Step 2: Compare with other git commands

   Unlike merge, rebase rewrites commit history without creating merge commits.

3. Final Answer:

   Moves your commits to a new base commit to create a linear history -> Option D

4. Quick Check:

   Rebase = move commits to new base [OK]

Hint: Rebase moves commits to a new base, unlike merge [OK]

Common Mistakes:

• Confusing rebase with merge
• Thinking rebase deletes commits
• Believing rebase creates new branches

2. Which of the following is the correct syntax to rebase your current branch onto main?

easy

A. git rebase --merge main

B. git rebase -m main

C. git rebase main

D. git rebase --onto main

Solution

1. Step 1: Recall basic git rebase syntax

   The command to rebase current branch onto another is git rebase <branch>.

2. Step 2: Identify correct option

   git rebase main matches the correct syntax: git rebase main.

3. Final Answer:

   git rebase main -> Option C

4. Quick Check:

   Rebase syntax = git rebase branch [OK]

Hint: Use 'git rebase branch-name' to rebase current branch [OK]

Common Mistakes:

• Adding unnecessary flags like -m or --merge
• Using --onto without required arguments
• Confusing rebase syntax with merge

3. Given the following commands run in sequence:

git checkout feature
git rebase main

What happens to the commits on feature branch?

medium

A. They are replayed on top of the latest commit on main

B. They are deleted and replaced by main commits

C. They remain unchanged and main is merged

D. They are copied to a new branch named main

Solution

1. Step 1: Understand what 'git rebase main' does on feature branch

   It takes commits from feature and replays them on top of main's latest commit.

2. Step 2: Clarify what happens to commits

   Commits are not deleted but moved to appear after main's commits, creating a linear history.

3. Final Answer:

   They are replayed on top of the latest commit on main -> Option A

4. Quick Check:

   Rebase = replay commits on new base [OK]

Hint: Rebase replays commits on top of target branch [OK]

Common Mistakes:

• Thinking commits get deleted
• Confusing rebase with merge
• Assuming new branches are created

4. You ran git rebase main on your feature branch but got conflicts. What is the correct way to continue after resolving conflicts?

medium

A. Run git rebase --continue

B. Run git merge --continue

C. Run git commit --amend

D. Run git rebase --abort to finish

Solution

1. Step 1: Identify the correct command after resolving rebase conflicts

   After fixing conflicts during rebase, you must run git rebase --continue to proceed.

2. Step 2: Differentiate from other commands

   git merge --continue is for merges, git commit --amend edits commits, and git rebase --abort cancels rebase.

3. Final Answer:

   Run git rebase --continue -> Option A

4. Quick Check:

   Fix conflicts then git rebase --continue [OK]

Hint: After conflicts, use 'git rebase --continue' to proceed [OK]

Common Mistakes:

• Using merge commands during rebase
• Aborting rebase instead of continuing
• Trying to amend commits prematurely

5. You rebased your feature branch onto main and now want to update the remote branch. What must you do to push your changes?

hard

A. Use git push normally without flags

B. Use git push --force to overwrite remote history

C. Delete the remote branch and push again

D. Use git push --no-verify to skip hooks

Solution

1. Step 1: Understand effect of rebase on commit history

   Rebase rewrites commit history, so remote branch history differs from local.

2. Step 2: Identify correct push method after rebase

   You must force push with git push --force to update remote branch with rewritten history.

3. Final Answer:

   Use git push --force to overwrite remote history -> Option B

4. Quick Check:

   Rebase requires force push to update remote [OK]

Hint: After rebase, always force push to update remote branch [OK]

Common Mistakes:

• Trying normal push after rebase
• Deleting remote branch unnecessarily
• Using push flags unrelated to rebase