Git आंतरिक रूप से कैसे काम करता है?

Question

Accepted Answer

आंतरिक रूप से, Git एक **content-addressable object store** है — यह सब कुछ **objects** (blobs, trees, commits, tags) के रूप में संग्रहीत करता है जिन्हें उनके **SHA-1 hash** द्वारा पहचाना जाता है। इस मॉडल को समझना Git को सरल बनाता है और यह बताता है कि इसके operations जैसे व्यवहार करते हैं वैसा क्यों करते हैं।

## Git एक content-addressable object store है

```text
Git stores 4 types of OBJECTS, each identified by the SHA-1 HASH of its content:
  BLOB   → file CONTENTS (just the data, no filename)
  TREE   → a directory: maps names → blobs (files) and trees (subdirs) + permissions
  COMMIT → a snapshot: points to a TREE (the root) + parent commit(s) + author/message
  TAG    → an annotated tag object (points to a commit, with metadata)
→ Content-addressable: an object's ID IS the hash of its content (same content = same hash).
```

## एक commit एक snapshot है, diff नहीं

```text
→ Each COMMIT points to a complete TREE (the full state of the project at that point)
→ Git stores SNAPSHOTS, not diffs (though it compresses/deduplicates internally):
  unchanged files → the commit's tree just REUSES the same blob (same hash) → efficient
→ Diffs you see are COMPUTED between snapshots, not stored.
```

## यह सब कैसे जुड़ता है

```text
Branch (e.g. main) → a pointer (a ref) to a COMMIT
HEAD → points to the current branch (or commit)
Commit → tree → blobs (the snapshot)
Commit → parent → parent → ... (the history chain)
→ Branches/tags are just small files containing a commit hash (cheap pointers).
  That's WHY branching is so lightweight.
```

## यह Git के व्यवहार को क्यों समझाता है

```text
✓ Branches are cheap → they're just a 40-char hash in a file (not file copies)
✓ Integrity → content-addressing means corruption/changes are detectable (hash mismatch)
✓ Commits are immutable → changing anything = a new hash = a new commit (why rebase
  creates NEW commits, why history rewriting changes hashes)
✓ Deduplication → identical content stored once (shared blobs)
```

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

Git आंतरिक रूप से कैसे काम करता है यह समझना मूल्यवान senior-स्तरीय ज्ञान है क्योंकि यह **Git को सरल बनाता है** और बताता है कि इसके operations जैसा व्यवहार करते हैं वैसा *क्यों* करते हैं, Git के बारे में तर्क करने और आत्मविश्वास से उपयोग करने की आपकी क्षमता को गहरा करता है।

मूल मॉडल — Git एक **content-addressable object store** के रूप में जिसमें चार object प्रकार हैं (file contents के लिए blobs, directories के लिए trees, snapshots के लिए commits, tags) प्रत्येक अपनी **content के hash** द्वारा पहचाना जाता है — वह नींव है जिस पर बाकी सब कुछ टिका है।

यह समझना कि **एक commit एक snapshot है, diff नहीं** (प्रत्येक commit एक पूर्ण tree की ओर इशारा करता है जो पूरे project state का प्रतिनिधित्व करता है, अपरिवर्तित files कुशलता से समान blobs का पुन: उपयोग करते हुए, और diffs संग्रहीत होने के बजाय computed किए जाते हैं) एक सामान्य गलतफहमी को सुधारता है और Git के snapshot-आधारित मॉडल को समझाता है।

**यह सब कैसे जुड़ता है** यह देखना (branches और tags commits के लिए सस्ते pointers/refs के रूप में, HEAD वर्तमान branch की ओर इशारा करते हुए, commits parents के माध्यम से श्रृंखलाबद्ध) नीचे की सुरुचिपूर्ण सरलता को प्रकट करता है।

सबसे मूल्यवान रूप से, यह समझ **Git के अवलोकन योग्य व्यवहार को समझाती है**: **branches हल्के क्यों हैं** (बस एक छोटी file में एक hash, file copies नहीं — यह समझाते हुए कि branching इतनी तेज़ क्यों है), Git में **integrity क्यों है** (content-addressing hash mismatches के माध्यम से corruption का पता लगाता है), **commits immutable क्यों हैं** और rebase जैसे history-rewriting operations **नए hashes के साथ नए commits क्यों बनाते हैं** (किसी भी content को बदलने से hash बदल जाता है), और Git **deduplicate क्यों करता है** (समान content एक बार संग्रहीत)।

यह गहरा मॉडल Git को याद किए गए commands के एक सेट से एक समझने योग्य प्रणाली में बदल देता है, जटिल operations के बारे में आत्मविश्वासपूर्ण तर्क को सक्षम बनाता है।

चूँकि आंतरिक object मॉडल को समझना यह समझाता है कि Git जैसा व्यवहार करता है वैसा क्यों करता है (हल्के branches, immutable commits, rewriting पर hash परिवर्तन, integrity) और किसी को Git का उपयोग करने से वास्तव में समझने तक उन्नत करता है, Git internals को समझना मूल्यवान senior-स्तरीय ज्ञान है — एक ऐसा विषय जो senior भूमिकाओं के लिए अपेक्षित गहराई को दर्शाता है और Git के बारे में आत्मविश्वास से तर्क करने का मानसिक मॉडल प्रदान करता है, इसके व्यवहार को सरल बनाता है और उन्नत operations को रहस्यमय के बजाय समझने योग्य बनाता है।