Git Advanced – Rebase, Cherry-Pick & Workflows für Teams (2025)

~18 Min. Lesezeit · Veröffentlicht am 19. November 2025

Interactive Rebase – History säubern

Interactive Rebase ist eines der mächtigsten Git-Features. Damit kannst du deine Commit-History bearbeiten, bevor du sie mit anderen teilst.

Warum Interactive Rebase?

• Commits zusammenfassen (squash)
• Commit-Messages verbessern
• Reihenfolge ändern
• Ungewollte Commits entfernen

So funktioniert's

# Die letzten 3 Commits bearbeiten
git rebase -i HEAD~3

# Oder ab einem bestimmten Commit
git rebase -i abc1234

# Im Editor siehst du dann:
pick abc1234 Feature implementiert
pick def5678 Typo gefixt
pick ghi9012 Tests hinzugefügt

# Ändern zu:
pick abc1234 Feature implementiert
squash def5678 Typo gefixt
squash ghi9012 Tests hinzugefügt

# Das Ergebnis: Ein sauberer Commit statt drei kleiner

Praktisches Beispiel: Feature-Branch säubern

#!/bin/bash
# Workflow für saubere Feature-Branches

# 1. Feature-Branch erstellen
git checkout -b feature/user-authentication

# 2. Mehrere Commits während Entwicklung
git commit -m "Add login form"
git commit -m "Fix typo"
git commit -m "Add validation"
git commit -m "Fix another typo"
git commit -m "Add tests"

# 3. Vor dem Merge: History säubern
git rebase -i main

# 4. Im Editor: Typo-Fixes squashen
pick abc1234 Add login form
fixup def5678 Fix typo
pick ghi9012 Add validation
fixup jkl3456 Fix another typo
pick mno7890 Add tests

# 5. Resultat: 3 saubere Commits statt 5

Cherry-Pick – Commits gezielt übernehmen

Cherry-Pick ermöglicht es dir, einzelne Commits aus einem Branch in einen anderen zu übernehmen, ohne den ganzen Branch zu mergen.

Wann Cherry-Pick nutzen?

• Hotfix vom develop auf main übertragen
• Feature teilweise backporten
• Commit aus falschem Branch holen
• Bug-Fix in mehrere Releases übernehmen

# Einzelnen Commit cherry-picken
git cherry-pick abc1234

# Mehrere Commits
git cherry-pick abc1234 def5678

# Commit-Range
git cherry-pick abc1234..ghi9012

# Ohne automatischen Commit (staging only)
git cherry-pick -n abc1234

# Bei Konflikten
git cherry-pick --continue
# oder
git cherry-pick --abort

Real-World Beispiel: Hotfix Distribution

#!/bin/bash
# Hotfix auf mehrere Release-Branches anwenden

# Hotfix auf develop erstellen
git checkout develop
git commit -m "Fix: Critical security issue"
HOTFIX_COMMIT=$(git rev-parse HEAD)

# Auf alle aktiven Release-Branches anwenden
for branch in release/1.0 release/1.1 release/2.0; do
  echo "Applying hotfix to $branch"
  git checkout $branch
  git cherry-pick $HOTFIX_COMMIT
  git push origin $branch
done

git checkout develop

Stash Management für Profis

Git Stash speichert deine Änderungen temporär, ohne einen Commit zu erstellen. Perfekt für schnelle Context-Switches.

Advanced Stash Commands

# Stash mit Message
git stash save "WIP: Feature X Implementation"

# Nur bestimmte Dateien stashen
git stash push -m "Config changes" -- config/*

# Auch untracked Files stashen
git stash -u

# Stash Liste anzeigen
git stash list
# stash@{0}: On main: WIP: Feature X Implementation
# stash@{1}: On develop: Config changes

# Bestimmten Stash anwenden
git stash apply stash@{1}

# Stash in neuen Branch
git stash branch feature/from-stash

# Einzelne Datei aus Stash
git checkout stash@{0} -- path/to/file.js

# Stash inspizieren
git stash show -p stash@{0}

# Partial Stash mit Interactive Mode
git stash push -p -m "Partial changes"

# Stash als Patch speichern
git stash show -p > my-changes.patch

# Später wieder anwenden
git apply my-changes.patch

Git Bisect – Bugs effizient finden

Git Bisect nutzt binäre Suche, um den Commit zu finden, der einen Bug eingeführt hat. Extrem effizient bei großer History.

Manuelles Bisecting

# Bisect starten
git bisect start

# Aktueller Commit ist fehlerhaft
git bisect bad

# Letzter bekannter guter Commit
git bisect good v1.0

# Git checkt automatisch Commits aus
# Nach jedem Test:
git bisect good  # oder
git bisect bad

# Am Ende zeigt Git den problematischen Commit
# Bisect beenden
git bisect reset

Automatisiertes Bisecting

#!/bin/bash
# test-script.sh
npm test
if [ $? -eq 0 ]; then
  exit 0  # Tests passed = good
else
  exit 1  # Tests failed = bad
fi

# Automatisch bisecten
git bisect start HEAD v1.0
git bisect run ./test-script.sh

Team Workflows im Vergleich

Git Flow

Der Klassiker für größere Teams mit geplanten Releases.

# Git Flow Branches
main        # Production-ready code
develop     # Integration branch
feature/*   # Feature branches
release/*   # Release preparation
hotfix/*    # Emergency fixes

# Feature entwickeln
git checkout -b feature/payment develop
# ... entwickeln ...
git checkout develop
git merge --no-ff feature/payment

GitHub Flow

Simpler Workflow für Continuous Deployment.

# GitHub Flow - nur main und feature branches
main         # Immer deploybar
feature/*    # Kurze Feature branches

# Workflow
git checkout -b feature/new-feature
# ... entwickeln & pushen ...
# Pull Request erstellen
# Nach Review: Merge to main
# Automatisches Deployment

GitLab Flow

Kombination aus Git Flow und GitHub Flow mit Environment-Branches.

# GitLab Flow
main         # Latest code
pre-prod     # Staging environment
production   # Production environment

# Upstream first
git checkout -b feature/x main
# ... entwickeln ...
git checkout main
git merge feature/x
# Dann downstream
git checkout pre-prod
git merge main

Branch-Strategien

Branch Protection Rules

# GitHub CLI für Branch Protection
gh api repos/:owner/:repo/branches/main/protection \
  --method PUT \
  --field required_status_checks='{"strict":true,"contexts":["continuous-integration"]}' \
  --field enforce_admins=true \
  --field required_pull_request_reviews='{"required_approving_review_count":2}'

Branch Naming Conventions

# Gute Branch-Namen
feature/JIRA-123-user-authentication
bugfix/JIRA-456-fix-login-error
hotfix/JIRA-789-security-patch
refactor/payment-module
docs/api-documentation
test/e2e-user-flow

# Git Hooks für Enforcement
#!/bin/bash
# .git/hooks/pre-push
branch=$(git rev-parse --abbrev-ref HEAD)
valid_pattern="^(feature|bugfix|hotfix|refactor|docs|test)\/[A-Z]+-[0-9]+-"

if ! [[ "$branch" =~ $valid_pattern ]]; then
  echo "Branch name '$branch' does not follow naming convention"
  echo "Use: feature/JIRA-123-description"
  exit 1
fi

Merge-Konflikte meistern

Konflikte verstehen

# Konflikt-Marker
<<<<<<< HEAD
const config = {
  apiUrl: 'https://api.production.com'
};
=======
const config = {
  apiUrl: 'https://api.staging.com'
};
>>>>>>> feature/new-api

# Konflikt lösen
const config = {
  apiUrl: process.env.API_URL || 'https://api.production.com'
};

Konflikt-Resolution Strategies

# Ihre Version behalten
git checkout --ours path/to/file

# Andere Version nehmen
git checkout --theirs path/to/file

# Merge abbrechen
git merge --abort

# Rebase bei Konflikten
git rebase --continue  # Nach Konfliktlösung
git rebase --skip      # Commit überspringen
git rebase --abort     # Rebase abbrechen

# 3-Way Merge Tool
git mergetool --tool=vimdiff

Git Hooks & Automation

Pre-Commit Hook

#!/bin/bash
# .git/hooks/pre-commit

# Prettier ausführen
npm run prettier:check || {
  echo "❌ Prettier check failed. Run 'npm run prettier:fix'"
  exit 1
}

# ESLint
npm run lint || {
  echo "❌ ESLint failed"
  exit 1
}

# Keine console.logs
if git diff --cached --name-only | xargs grep -n "console.log"; then
  echo "❌ Remove console.log statements"
  exit 1
fi

echo "✅ Pre-commit checks passed"

Commit-Message Hook

#!/bin/bash
# .git/hooks/commit-msg

# Conventional Commits enforces
commit_regex='^(feat|fix|docs|style|refactor|test|chore)(\(.+\))?: .{1,50}'

if ! grep -qE "$commit_regex" "$1"; then
  echo "❌ Invalid commit message format!"
  echo "📝 Format: (): "
  echo "📌 Example: feat(auth): add login functionality"
  exit 1
fi

Praktische Beispiele

Release automatisieren

#!/bin/bash
# release.sh - Automatisches Release-Script

VERSION=$1
if [ -z "$VERSION" ]; then
  echo "Usage: ./release.sh v1.2.3"
  exit 1
fi

# Release-Branch erstellen
git checkout -b release/$VERSION develop

# Version Bumping
npm version $VERSION --no-git-tag-version

# Changelog generieren
npx conventional-changelog -p angular -i CHANGELOG.md -s

# Commits
git add .
git commit -m "chore(release): prepare release $VERSION"

# In main mergen
git checkout main
git merge --no-ff release/$VERSION -m "Merge release $VERSION"
git tag -a $VERSION -m "Release $VERSION"

# Zurück in develop mergen
git checkout develop
git merge --no-ff release/$VERSION

# Aufräumen
git branch -d release/$VERSION

# Pushen
git push origin main develop --tags

echo "✅ Release $VERSION completed!"

Feature-Toggle Workflow

#!/bin/bash
# Feature Toggle für sichere Deployments

# Feature Branch mit Toggle
git checkout -b feature/new-dashboard

# Feature Toggle hinzufügen
cat > features.json << EOF
{
  "newDashboard": {
    "enabled": false,
    "rollout": 0
  }
}
EOF

# Entwicklung mit Toggle
if (features.newDashboard.enabled) {
  // Neues Dashboard
} else {
  // Altes Dashboard
}

# Schrittweises Rollout
{
  "newDashboard": {
    "enabled": true,
    "rollout": 10  // 10% der User
  }
}

Advanced Git Cheatsheet

# History Management
git rebase -i HEAD~n            # Interactive rebase
git cherry-pick SHA              # Pick specific commit
git revert SHA                   # Undo commit (safe)
git reset --hard SHA             # Reset to commit (dangerous)
git reset --soft HEAD~1          # Undo last commit, keep changes

# Stash Operations
git stash save "message"         # Stash with message
git stash pop                    # Apply and remove stash
git stash apply stash@{n}        # Apply specific stash
git stash branch new-branch      # Create branch from stash

# Debugging
git bisect start                 # Start bisecting
git blame file.js                # Show who changed what
git log -p file.js               # File history with diffs
git reflog                       # Show all ref updates

# Cleanup
git clean -fd                    # Remove untracked files
git gc --prune=now               # Garbage collection
git remote prune origin          # Clean remote branches

# Advanced Log
git log --oneline --graph --all  # Visual branch history
git log --grep="pattern"         # Search commit messages
git log -S"code"                 # Search code changes
git log --since="2 weeks ago"    # Time-based filtering

# Aliases für Produktivität
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual '!gitk'

Fazit & Best Practices

Git Advanced Techniques machen den Unterschied zwischen einem Hobby-Entwickler und einem Profi. Die wichtigsten Takeaways:

• Saubere History: Nutze Interactive Rebase für aussagekräftige Commit-Historie
• Gezieltes Cherry-Picking: Übernehme nur was du brauchst
• Workflow wählen: Git Flow, GitHub Flow oder GitLab Flow - je nach Team und Projekt
• Automatisierung: Git Hooks sparen Zeit und vermeiden Fehler
• Konflikte meistern: Mit den richtigen Tools und Strategien