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:

shCopy
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:

shCopy
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:

shCopy
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:

   shCopy
   git add .
   git rebase --continue
   

3. If something goes wrong, abort the rebase:

   shCopy
   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:

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

2. Create and switch to a new branch:

   shCopy
   git checkout -b feature-branch
   

3. Create a new file and commit it:

   shCopy
   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:

   shCopy
   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:

   shCopy
   git checkout feature-branch
   git rebase main
   

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

   shCopy
   git add file.txt
   git rebase --continue
   

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

   shCopy
   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.