如何自动变基多个连续的Git分支？

Great question—chaining rebases across dependent branches is a common pain point, but there's a straightforward way to automate it once you understand the dependency order. Let's break this down:

Core Logic #

Your branch chain is origin/master → [old master] → branch1 → branch2 → branch3. Since each branch builds on the one below it, you must rebase from the bottom up: start with the branch closest to origin/master (branch1), then branch2, then branch3. Rebasing top-down would leave intermediate branches on outdated history, leading to conflicts or messy merges later.

Manual Step-by-Step (For Context) #

First, let's confirm the manual workflow to see why automation works:

1. Fetch latest remote changes:

   git fetch origin
   

2. Backup all branches (critical—rebase rewrites history, so backups save you if something goes wrong):

   git branch branch1-bkp branch1
   git branch branch2-bkp branch2
   git branch branch3-bkp branch3
   

3. Rebase branch1 onto origin/master:

   git checkout branch1
   git rebase origin/master
   

   Resolve any conflicts, run git add ., then git rebase --continue until complete.
4. Rebase branch2 onto the updated branch1:

   git checkout branch2
   git rebase branch1
   

   Repeat conflict resolution steps if needed.
5. Rebase branch3 onto the updated branch2:

   git checkout branch3
   git rebase branch2
   

Automated Bash Script #

To avoid repeating these steps manually, you can use a bash script that handles the chain automatically. It follows the same bottom-up order, backs up branches, and handles conflict prompts:

#!/bin/bash

# Define your branch chain in ORDER: start with the branch closest to origin/master, end with the topmost branch
BRANCHES=("branch1" "branch2" "branch3")
UPSTREAM="origin/master"

# Check if working directory is clean (prevents rebase failures)
if ! git diff --quiet; then
    echo "Error: Uncommitted changes detected. Please stash or commit them first."
    exit 1
fi

# Fetch latest remote updates
echo "🔄 Fetching latest changes from origin..."
git fetch origin

# Backup all branches
echo "📦 Backing up branches..."
for branch in "${BRANCHES[@]}"; do
    git branch "${branch}-bkp" "${branch}"
done

# Rebase each branch in order
previous_upstream="${UPSTREAM}"
for branch in "${BRANCHES[@]}"; do
    echo "\n🔨 Rebasing ${branch} onto ${previous_upstream}..."
    git checkout "${branch}"
    if ! git rebase "${previous_upstream}"; then
        echo "\n⚠️ Conflict detected in ${branch}. Please resolve conflicts, then run 'git rebase --continue'."
        echo "Once resolved, you can re-run this script to finish the remaining rebases."
        exit 1
    fi
    # Update upstream for the next branch to this freshly rebased branch
    previous_upstream="${branch}"
done

echo "\n✅ All branches rebased successfully!"
git checkout master # Optional: return to master branch

How to Use the Script: #

1. Save it as rebase-chain.sh
2. Make it executable: chmod +x rebase-chain.sh
3. Run it: ./rebase-chain.sh

Key Notes #

• Branch Order Matters: Double-check the BRANCHES array is ordered from the lowest (closest to origin/master) to highest branch in your chain.
• Conflict Handling: The script will pause if it hits a conflict. Resolve the conflict in your editor, run git add ., then git rebase --continue. Once done, re-run the script to finish the rest of the chain.
• Backups: The script creates backup branches (e.g., branch1-bkp) so you can restore if something goes wrong: git branch -f branch1 branch1-bkp.
• Avoid Force-Pushing Prematurely: Don't force-push any branches until all rebases are complete and you've verified the history looks correct with git log --oneline --decorate.

内容的提问来源于stack exchange，提问作者sdeleon28