rebase और merge में क्या अंतर है?

Question

Accepted Answer

**merge** और **rebase** दोनों एक branch से दूसरी में बदलाव एकीकृत करते हैं, लेकिन वे इसे अलग ढंग से करते हैं: merge एक merge commit के साथ **इतिहास को संरक्षित करता है**, जबकि rebase एक रैखिक अनुक्रम बनाने के लिए **इतिहास को rewrite करता है**। अंतर और प्रत्येक का कब उपयोग करना है यह समझना महत्वपूर्ण है।

## Merge — इतिहास को संरक्षित करता है (संयोजित करता है)

```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 — रैखिक इतिहास के लिए rewrite करता है (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 आपकी branch के commits को दूसरी branch के शीर्ष से शुरू होने के लिए **स्थानांतरित** करता है, नए commits बनाते हुए — एक साफ़, रैखिक इतिहास उत्पन्न करता है।

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

## प्रत्येक का कब उपयोग करें

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

## यह क्यों महत्वपूर्ण है

rebase और merge के बीच अंतर को समझना महत्वपूर्ण है क्योंकि दोनों बदलाव एकीकृत करते हैं पर इतिहास पर मौलिक रूप से अलग प्रभावों के साथ, और सही (और सुरक्षित रूप से) चुनना मायने रखता है, इसलिए यह मूल्यवान Git ज्ञान है जिस पर आमतौर पर चर्चा भी होती है।

मुख्य भेद — **merge इतिहास को संरक्षित करता है** (एक merge commit बनाते हुए जो branches के संयोजन को रिकॉर्ड करता है, सच्चे विकास इतिहास को बनाए रखते हुए) जबकि **rebase इतिहास को rewrite करता है** (commits को दूसरी branch के शीर्ष पर replay करके एक साफ़, रैखिक अनुक्रम बनाता है मानो काम नवीनतम कोड पर किया गया हो) — प्रभावित करता है कि प्रोजेक्ट इतिहास कैसा दिखता और पढ़ा जाता है।

trade-offs (merge: सटीक पर संभावित रूप से merge commits से अव्यवस्थित; rebase: साफ़ और रैखिक पर commits को rewrite करता है) को समझना यह चुनने में मदद करता है कि आप सच्चे इतिहास को महत्व देते हैं या रैखिक सफ़ाई को।

सबसे महत्वपूर्ण रूप से, **rebasing के सुनहरे नियम** को समझना — **उन commits को कभी rebase न करें जो push/साझा हो चुके हैं** — ज़रूरी है क्योंकि rebasing commits को rewrite करता है (उन्हें नए hashes देते हुए), इसलिए साझा इतिहास को rebase करना सहयोगियों के पास जो है उससे भिन्न हो जाता है, गंभीर भ्रम और conflicts पैदा करते हुए; rebase केवल local, unpushed commits के लिए सुरक्षित है।

यह सुरक्षा नियम अति-आवश्यक है और उल्लंघन होने पर समस्याओं का एक सामान्य स्रोत।

**प्रत्येक का कब उपयोग करें** (साझा branches एकीकृत करने और इतिहास संरक्षित करने के लिए merge, अक्सर pull requests के माध्यम से features को merge करने के लिए टीम की डिफ़ॉल्ट; साझा करने से पहले local commits साफ़ करने या किसी feature branch को रैखिक रूप से अद्यतन रखने के लिए rebase — केवल local commits पर) को समझना ठोस Git अभ्यास को दर्शाता है।

चूँकि बदलाव एकीकृत करना मौलिक है और merge-बनाम-rebase विकल्प (इसके इतिहास और सुरक्षा निहितार्थों के साथ) एक बार-बार होने वाला निर्णय और interview विषय है, अंतर को समझना — इतिहास पर उनके प्रभाव, महत्वपूर्ण सुनहरा नियम, और प्रत्येक का कब उपयोग करें — मूल्यवान, व्यावहारिक रूप से महत्वपूर्ण Git ज्ञान है जो इतिहास को सुरक्षित रूप से साफ़ रखने के केंद्र में है और एक आमतौर पर चर्चित भेद जिसे हर developer को समझना चाहिए।