What is Git Rebase?

Git rebase is a powerful tool that helps you update your branch by applying its changes on top of another branch, typically the latest version of main or develop. Unlike git merge, which creates a new merge commit, rebasing keeps the commit history cleaner and more linear.

Why Use Git Rebase?

• Keeps history clean – Avoids unnecessary merge commits.
• Improves readability – Creates a straight-line commit history.
• Helps prevent conflicts early – Incorporates upstream changes incrementally.
• Useful for squashing commits – Allows you to combine multiple commits before merging.

When to Use Git Rebase

1. Updating Your Feature Branch

If you're working on a feature branch and the main branch has new updates, rebase your branch before merging:

git checkout feature-branch
git fetch origin
git rebase origin/main

This applies your commits on top of the latest main branch.

2. Squashing Commits Before Merging

If you’ve made multiple commits that should be combined into one, use interactive rebase:

git rebase -i HEAD~3  # Squashes the last 3 commits

Then, choose squash (or s) for commits you want to merge.

3. Avoiding Merge Commits

Instead of merging a feature branch, you can rebase to keep history linear:

git checkout main
git pull origin main
git checkout feature-branch
git rebase main

When Not to Use Git Rebase

• On shared branches – Rebasing changes commit history, which can cause conflicts if others have based work on the original branch.
• If unsure – If history rewriting isn't necessary, merging might be simpler.
• For long-running feature branches – If rebasing causes too many conflicts, consider merging instead.

How to Handle Conflicts During Rebase

If you encounter conflicts, Git will pause the rebase and prompt you to resolve them:

1. Manually fix the conflicts in your files.
2. Mark the conflicts as resolved:

   git add .
   git rebase --continue
   

3. If something goes wrong, abort the rebase:

   git rebase --abort
   

Step-by-Step Rebase Exercise

Follow this exercise to practice Git rebase in a controlled environment.

Setup

1. Create a new directory and initialize a Git repository:

   mkdir git-rebase-exercise && cd git-rebase-exercise
   git init
   

2. Create and switch to a new branch:

   git checkout -b feature-branch
   

3. Create a new file and commit it:

   echo "Initial content" > file.txt
   git add file.txt
   git commit -m "Initial commit on feature branch"
   

Simulating Main Branch Updates

4. Switch back to main and add a change:

   git checkout main
   echo "Main branch update" > file.txt
   git add file.txt
   git commit -m "Update from main branch"
   

Rebasing Feature Branch

5. Switch back to feature-branch and start the rebase:

   git checkout feature-branch
   git rebase main
   

6. If there are conflicts, resolve them manually in file.txt and continue:

   git add file.txt
   git rebase --continue
   

7. Verify that history is clean by checking the log:

   git log --oneline --graph
   

Conclusion

Git rebase is a great tool for keeping your commit history clean and avoiding unnecessary merge commits. However, it should be used carefully to avoid disrupting shared branches. By understanding when and how to use it, you can work more efficiently and keep your Git history readable.