The rebase operation (git rebase)

Rebasing is a powerful feature in Git that allows developers to tidy up commit history, merge branches, or modify commit records. Unlike merge operations, it achieves a more linear history by reapplying commits, but it should be used cautiously to avoid collaboration issues when operating on public branches.

Basic Concepts of Rebasing

The core idea of rebasing is to "move" the commits of the current branch to another base point (usually the latest commit of the target branch). Unlike git merge, rebasing rewrites commit history, resulting in a clearer and more linear project history. For example:

# Currently on the feature branch
git rebase main

This command "replays" the commits of the feature branch onto the latest commit of the main branch. The original commits are replaced with new ones, and although the changes remain the same, the commit hashes will change.

Rebasing vs. Merging

Merge operations preserve the history of all branches by creating a new merge commit, while rebasing rearranges the commit order into a straight line:

• History after merging:

  *   Merge commit (main)
  |\
  | * Commit C (feature)
  | * Commit B
  |/
  * Commit A
  

• History after rebasing:

  * Commit C' (feature)
  * Commit B'
  * Commit A (main)
  

Rebasing is more suitable for tidying up local branches, while merging is better for integrating public branches.

Interactive Rebasing

Interactive rebasing (git rebase -i) allows developers to edit, combine, or delete commits. For example, to modify the last three commits:

git rebase -i HEAD~3

This opens an editor with content like:

pick 1a2b3c Commit 1
pick 4d5e6f Commit 2
pick 7g8h9i Commit 3

You can modify it to:

pick 1a2b3c Commit 1
squash 4d5e6f Commit 2
fixup 7g8h9i Commit 3

This will combine the latter two commits into the first one.

Resolving Rebase Conflicts

Conflicts may arise during rebasing, and Git will pause and prompt you to resolve them. For example:

git rebase main
# Conflicts occur
# Manually resolve file conflicts
git add .
git rebase --continue

If conflicts cannot be resolved, you can cancel the entire rebase operation with git rebase --abort.

Risks and Best Practices of Rebasing

1. Do not rebase pushed commits: This rewrites public history and causes issues for collaborators.
2. Rebase local branches frequently: Keep commit history tidy.
3. Back up important branches: Create backup branches before rebasing.
4. Team agreement: Establish clear rebasing rules within the team.

Advanced Rebase Techniques

Modifying Multiple Commit Messages

git rebase -i HEAD~5
# Change "pick" to "reword" for the commits to modify

Splitting Commits

git rebase -i HEAD~3
# Change "pick" to "edit"
git reset HEAD^
git add -p  # Interactive staging
git commit -m "First part of changes"
git commit -m "Second part of changes"
git rebase --continue

Using Exec Commands During Rebasing

You can execute commands for specific commits during interactive rebasing:

pick 1a2b3c Commit 1
exec npm test
pick 4d5e6f Commit 2

This will run tests immediately after applying Commit 1.

Rebasing and Remote Branches

To synchronize a local branch with a remote branch, use:

git pull --rebase origin main

This is equivalent to:

git fetch origin
git rebase origin/main

It produces a cleaner history than a direct git pull (which defaults to merging).

Rebase Workflow Example

Assume a feature development scenario:

1. Create a feature branch from main.
2. During development, main gets updates.
3. Rebase the feature branch onto the updated main:

git checkout feature
git fetch origin
git rebase origin/main

4. Resolve any conflicts.
5. Test the feature.
6. Push the feature branch (force push if already pushed).

Rebasing and Git Hooks

You can leverage Git hooks to automate tasks during rebasing. For example, add the following to .git/hooks/post-rewrite:

#!/bin/sh
[ "$1" = "rebase" ] && echo "Rebase completed. Consider running tests."

Rebasing in GUI Tools

Most Git GUI tools support rebasing. For example, in VS Code:

1. Open the Git view.
2. Right-click the target branch.
3. Select "Rebase current branch onto..."

Rebasing and Submodules

When working with projects containing submodules, extra care is needed:

git rebase --preserve-merges --rebase-merges main

This attempts to preserve merge commits related to submodules.

Performance Considerations for Rebasing

For large repositories or long-running branches, rebasing may:

• Consume significant memory.
• Require repeated conflict resolution.
• Take a long time.

In such cases, consider rebasing in stages:

git rebase --onto main feature~10 feature~5
git rebase --onto main feature~5 feature