Mi a különbség a rebase és a merge között?

Question

Accepted Answer

Mind a **merge**, mind a **rebase** egy másik ágról származó módosításokat integrál az aktuális ágba, azonban eltérő módon teszik ezt: a merge **megőrzi az előzményeket** egy merge commit-tal, míg a rebase **átírja az előzményeket** egy lineáris szekvencia létrehozásához. A különbség megértése és annak tudása, hogy mikor melyiket kell használni, fontos.

## Merge — megőrzi az előzményeket (kombinál)

```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 — átírja az előzményeket egy lineáris történethez (ismétlődik)

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

A rebase **áthelyezi** az ágad commit-jait, hogy egy másik ág csúcsára kezdődjenek, új commit-okat hozva létre — tiszta, lineáris történetet eredményezve.

## A rebase aranyonszabálya

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

## Mikor melyiket kell használni

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

## Miért számít ez

A rebase és merge közötti különbség megértése azért fontos, mert mindkettő integrál módosításokat, de alapvetően eltérő hatásokkal járnak az előzményekre, és a helyes (és biztonságos) választás számít, ezért értékes Git-tudás, amelyet gyakran tárgyalnak.

Az alapvető különbség — **a merge megőrzi az előzményeket** (egy merge commit-tal, amely rögzíti az egyesített ágakat, megőrizve a valódi fejlesztési történetet), míg a **rebase átírja az előzményeket** (commit-okat játszva le egy másik ág csúcsára, egy tiszta, lineáris szekvenciát létrehozva, mintha az utolsó kódon lett volna elvégezve a munka) — befolyásolja a projekttörténet megjelenését és olvashatóságát.

A kompromisszumok megértése (merge: pontos, de potenciálisan zsúfolt merge commit-okkal; rebase: tiszta és lineáris, de commit-ok átírásával) segít választani attól függően, hogy az igazi történetet vagy a lineáris tisztaságot értékeled-e jobban.

A legkritikusabb az, hogy megértsed a **rebase aranyszszabályát** — **soha ne rebase-elds azokat a commit-okat, amelyeket már fel készültél/megosztottál** — mert a rebase átírja a commit-okat (új hash-eket adva nekik), így a megosztott történet rebase-elése eltér attól, amit az együttműködők rendelkeznek, súlyos zavart és konfliktusokat okozva; a rebase csak helyi, fel nem készített commit-okra biztonságos.

Ez a biztonsági szabály létfontosságú és gyakori hibaforrás, amikor megsértik.

Annak megértése, hogy **mikor melyiket kell használni** (merge a megosztott ágak integrálásához és az előzmények megőrzéséhez, gyakran a csapat alapértelmezése a funkciók pull request-en keresztüli összevonásához; rebase a helyi commit-ok tisztítására a megosztás előtt vagy egy feature ág lineáris naprakészségének fenntartásához — csak helyi commit-okra), a hangtalan Git-gyakorlatot tükrözi.

Mivel a módosítások integrálása alapvető, és a merge versus rebase választás (az előzmények és biztonsági következményeivel) gyakori döntés és interjútéma, a különbség megértése — hatásuk az előzményekre, a kritikus aranyszszabály és mikor kell melyiket használni — értékes, gyakorlatilag fontos Git-tudás, amely központi a történet tisztán és biztonságosan tartásához, és ez egy közösen tárgyalt különbség, amelyet minden fejlesztőnek meg kell értenie.