Apa perbedaan antara rebase dan merge?

Question

Accepted Answer

Baik **merge** maupun **rebase** mengintegrasikan perubahan dari satu branch ke branch lain, namun mereka melakukannya dengan cara berbeda: merge **melestarikan history** dengan merge commit, sementara rebase **menulis ulang history** untuk membuat urutan linear. Memahami perbedaan dan kapan menggunakan masing-masing sangat penting.

## Merge — melestarikan history (menggabungkan)

```text
main:     A───B───C───────M     ← M is a MERGE COMMIT (two parents)
                  \       /
feature:           D───E
→ git merge feature: creates M combining the branches
  ✓ Preserves the actual history (shows the branch existed, when it merged)
  ✗ History has merge commits (can look cluttered with many merges)
```

## Rebase — menulis ulang untuk linear history (replay)

```text
BEFORE:  main: A───B───C    feature: A───B───D───E
AFTER rebase feature onto main:
         main: A───B───C    feature: A───B───C───D'───E'
→ git rebase main (on feature): REPLAYS feature's commits (D,E) ON TOP of main's latest (C)
  ✓ LINEAR, clean history (no merge commits) — as if feature was built on current main
  ✗ REWRITES commits (D→D', E→E' are NEW commits with new hashes)
```

Rebase **memindahkan** commit branch Anda untuk dimulai dari tip branch lain, membuat commit baru — menghasilkan history yang bersih dan linear.

## Aturan emas rebasing

```text
⚠️ NEVER rebase commits that have been PUSHED/SHARED (public history):
  → rebasing rewrites commits (new hashes) → diverges from what others have
  → causes serious confusion and conflicts for collaborators
→ Rebase only LOCAL, unpushed commits. Merge for integrating shared/public branches.
```

## Kapan menggunakan masing-masing

```text
MERGE  → integrating shared branches; preserving true history; team default for merging
  features to main (often via pull requests). Safe, non-destructive.
REBASE → cleaning up LOCAL commits before sharing; keeping a feature branch up-to-date
  with main (linear); achieving clean linear history. On local/private commits only.
→ Common workflow: rebase locally to tidy up, then merge (or PR) into main.
```

## Mengapa ini penting

Memahami perbedaan antara rebase dan merge penting karena keduanya mengintegrasikan perubahan namun dengan efek fundamentally berbeda pada history, dan memilih dengan benar (dan aman) sangat penting, jadi ini adalah pengetahuan Git yang berharga dan sering dibahas.

Perbedaan inti — **merge melestarikan history** (membuat merge commit yang mencatat branch digabungkan, menjaga true development history) sementara **rebase menulis ulang history** (replay commit ke tip branch lain untuk membuat urutan linear seolah-olah pekerjaan dilakukan di kode terbaru) — mempengaruhi bagaimana project history terlihat dan terbaca.

Memahami trade-off (merge: akurat namun potentially berantakan dengan merge commit; rebase: bersih dan linear namun menulis ulang commit) membantu memilih berdasarkan apakah Anda menghargai true history atau linear cleanliness.

Yang paling kritis, memahami **aturan emas rebasing** — **jangan pernah rebase commit yang telah dipush/dibagikan** — sangat penting karena rebase menulis ulang commit (memberikan hash baru), jadi rebase shared history diverges dari apa yang collaborator miliki, menyebabkan confusion dan conflict serius; rebase hanya aman untuk commit lokal yang unpushed.

Aturan safety ini vital dan sumber umum masalah ketika dilanggar.

Memahami **kapan menggunakan masing-masing** (merge untuk mengintegrasikan shared branch dan melestarikan history, sering menjadi team default untuk merge fitur via pull request; rebase untuk membersihkan local commit sebelum dibagikan atau menjaga feature branch linear up-to-date — pada local commit saja) mencerminkan sound Git practice.

Karena mengintegrasikan perubahan adalah fundamental dan pilihan merge-vs-rebase (dengan history dan safety implications) adalah frequent decision dan interview topic, memahami perbedaan — efek mereka pada history, critical golden rule, dan kapan menggunakan masing-masing — adalah valuable, practically-important Git knowledge yang central untuk maintain clean history dengan aman dan commonly-discussed distinction yang setiap developer harus pahami.