git rebase basic usage - Mini Project: Build & Apply

Git Rebase Basic Usage

📖 Scenario: You are working on a project with a main branch called main and a feature branch called feature. The main branch has new commits that you want to include in your feature branch to keep it up to date.

🎯 Goal: You will learn how to use git rebase to move your feature branch commits on top of the latest main branch commits. This helps keep a clean project history.

📋 What You'll Learn

Create a new branch called feature from main

Add a commit to the feature branch

Rebase the feature branch onto the latest main branch

Show the commit history after rebasing

💡 Why This Matters

🌍 Real World

Developers often need to keep their feature branches up to date with the main branch to avoid conflicts and maintain a clean history.

💼 Career

Knowing how to use <code>git rebase</code> is essential for collaborative software development and version control workflows.

1

Create the feature branch and add a commit

Create a new branch called feature from main using git checkout -b feature main. Then create a file named feature.txt with the content Feature work and commit it with the message add feature work.

Git

# Create and switch to the feature branch from main
# Create feature.txt with content 'Feature work'
# Add and commit the file
# Your code here

Hint

Use git checkout -b feature main to create and switch to the feature branch. Then create the file and commit it.

2

Add a new commit to main branch

Switch back to the main branch using git checkout main. Create a file named main.txt with the content Main branch update and commit it with the message update main branch.

Git

git checkout -b feature main
echo 'Feature work' > feature.txt
git add feature.txt
git commit -m "add feature work"
# Switch to main branch
# Create main.txt with content 'Main branch update'
# Add and commit the file
# Your code here

Hint

Use git checkout main to switch back. Then create and commit the new file.

3

Rebase the feature branch onto main

Switch to the feature branch using git checkout feature. Then run git rebase main to move your feature commits on top of the latest main commits.

Git

git checkout -b feature main
echo 'Feature work' > feature.txt
git add feature.txt
git commit -m "add feature work"
git checkout main
echo 'Main branch update' > main.txt
git add main.txt
git commit -m "update main branch"
# Switch to feature branch
# Rebase feature branch onto main
# Your code here

Hint

Use git checkout feature to switch back. Then run git rebase main to update your branch.

4

Show the commit history after rebasing

Run git log --oneline --graph --all to display the commit history graph showing the rebased commits.

Git

git checkout -b feature main
echo 'Feature work' > feature.txt
git add feature.txt
git commit -m "add feature work"
git checkout main
echo 'Main branch update' > main.txt
git add main.txt
git commit -m "update main branch"
git checkout feature
git rebase main
# Show the commit history graph
# Your code here

Hint

Use git log --oneline --graph --all to see a simple graph of all commits.

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