Apa bedane antara rebase lan merge?

Question

IT Interview Practice · Accepted Answer

Loro-lorone **merge** lan **rebase** nggabungake owah-owahane saka siji cabang menyang cabang liyane, nanging cara-caranya beda: merge **njaga sejarah** kanthi merge commit, dene rebase **nulis ulang sejarah** kanggo nggawe urutan linear. Ngerti bedane lan kapan kudu nganggo saben-saben iku penting.

## Merge — njaga sejarah (nggabung)

```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 — nulis ulang kanggo sejarah linear (muter maneh)

```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 **mindhah** commits cabang mu kanggo diwiwiti saka pucuk cabang liyane, nggawe commits anyar — ngasilake sejarah bersih lan 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 kudu nganggo saben-saben

```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.
```

## Apa gunane

Ngerti bedane antara rebase lan merge iku penting amarga loro-lorone nggabungake owah-owahane nanging kanthi efek beda-beda ing sejarah, lan milih kanthi bener (lan aman) iku penting, dadi iki ilmu Git sing berguna lan asring diomongake.

Bedane inti — **merge njaga sejarah** (nggawe merge commit sing nyatat cabang-cabang digabung, njaga sejarah pangembangan sing sejati) dene **rebase nulis ulang sejarah** (muter maneh commits menyang pucuk cabang liyane kanggo nggawe urutan linear paringan kaya-kaya karya wis digarap ing kode paling anyar) — ngaruhi carane sejarah proyek katon lan kaya dicicritakake.

Ngerti tukar-tambaran (merge: akurat nanging kadhang-kadhang semrawut kanthi merge commits; rebase: bersih lan linear nanging nulis ulang commits) mbantu pilih adhedhasar apa sing luwih berharga: sejarah asli utawa kabersihen linear.

Paling krusial, ngerti **aturan emas rebasing** — **aja rebase commits sing wis dipush/dibagiake** — iku perlu amarga rebase nulis ulang commits (menehi hash anyar), dadi rebasing sejarah sing dibagiake nyimpang saka apa sing kuwe kolaborator, nyebabake kebingunan lan konflik serius; rebase aman mung kanggo commits lokal sing durung dipush.

Aturan keamanan iki penting lan asring jadi sumber masalah yen dilanggar.

Ngerti **kapan kudu nganggo saben-saben** (merge kanggo nggabungake cabang sing dibagiake lan njaga sejarah, asring dadi standar tim kanggo nggabungake fitur liwat pull requests; rebase kanggo resiki commits lokal sadurunge dibagiake utawa njaga cabang fitur tetep langsung up-to-date — mung commits lokal) nggambarake praktik Git sing apik.

Amarga nggabungake owah-owahane iku fundamental lan pilihan merge-versus-rebase (kanthi dampak sejarah lan keamanan) iku keputusan asring lan topik interview, ngerti bedane — epek-epeke ing sejarah, aturan emas krusial, lan kapan kudu nganggo saben-saben — iku ilmu Git sing berguna, praktis penting, lan sentral kanggo njaga sejarah bersih kanthi aman lan beda-bedane sing asring diomongake sing mesthi dimenger saben-saben developer.

Merge — njaga sejarah (nggabung)

Rebase — nulis ulang kanggo sejarah linear (muter maneh)

Aturan emas rebasing

Kapan kudu nganggo saben-saben

Apa gunane

Pitakon sing gegandhengan