Git Merge vs Rebase vs Squash - A Simple Guide#

Merge: Combining Branches#

Merging is like adding your changes alongside others’ work. It creates a new commit that combines two branches.

1
# Scenario: Merging feature branch into main
2
git checkout main
3
git merge feature-branch

What happens:

1
Before merge:
2
main:     A---B---C
3
feature:      \
4
               D---E
5

6
After merge:
7
main:     A---B---C---F
8
feature:      \     /
9
               D---E

When to use merge:

• When you want to preserve the branch history
• For feature branches that represent complete, logical units of work
• When working on long-running branches

Rebase: Reorganizing History#

Rebasing is like moving your changes to start from a different point. It makes history linear and clean.

1
# Scenario: Rebasing feature branch onto main
2
git checkout feature-branch
3
git rebase main

What happens:

1
Before rebase:
2
main:     A---B---C
3
feature:      \
4
               D---E
5

6
After rebase:
7
main:     A---B---C
8
                   \
9
                    D'---E'

When to use rebase:

• When you want a clean, linear project history
• Before merging your feature branch into main
• When updating your feature branch with latest changes from main

Squash: Combining Multiple Commits#

Squashing combines multiple commits into one, making history cleaner and more organized.

1
# Scenario: Squashing last 3 commits
2
git rebase -i HEAD~3

What happens:

1
Before squash:
2
A---B---C---D---E
3

4
After squash:
5
A---B---F        # where F contains changes from C, D, and E

Real-World Example#

Let’s see how these work together in a typical workflow:

1
# Start a feature branch
2
git checkout -b feature/user-auth
3
git commit -m "Add login form"
4
git commit -m "Add validation"
5
git commit -m "Fix typos"
6

7
# Main branch has new updates
8
# Option 1: Merge
9
git checkout main
10
git merge feature/user-auth
11

12
# Option 2: Rebase and Squash
13
git checkout feature/user-auth
14
git rebase -i main  # Squash commits during rebase
15

16
# In the rebase interactive editor:
17
pick abc123 Add login form
18
squash def456 Add validation
19
squash ghi789 Fix typos

Quick Decision Guide#

Choose Merge when:

• You want to preserve complete history
• Working with shared branches
• Need to maintain branch context

Choose Rebase when:

• You want a clean, linear history
• Working on a personal feature branch
• Need to integrate latest changes from main

Use Squash when:

• You have multiple small, related commits
• Want to clean up before merging
• Need to simplify history

Best Practices#

1. Never rebase shared branches
2. Squash before merging feature branches
3. Use meaningful commit messages
4. Keep feature branches short-lived
5. Regularly sync with main branch

Remember: There’s no “best” option - each has its use case. Choose based on your team’s workflow and project needs.