Git ਅੰਦਰੋਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

Question

Accepted Answer

ਅੰਦਰੋਂ, Git ਇੱਕ **content-addressable object store** ਹੈ — ਇਹ ਸਭ ਕੁਝ **objects** (blobs, trees, commits, tags) ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ ਜੋ ਉਹਨਾਂ ਦੇ **SHA-1 hash** ਦੁਆਰਾ ਪਛਾਨੇ ਜਾਂਦੇ ਹਨ। ਇਸ ਮਾਡਲ ਨੂੰ ਸਮਝਣਾ Git ਨੂੰ ਦਸਿਆ-ਰਹਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ ਇਸਦੀਆਂ ਕਾਰਵਾਈਆਂ ਕਿਉਂ ਇਸ ਤਰ੍ਹਾਂ ਵਰਤਾਓ ਕਰਦੀਆਂ ਹਨ।

## 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-level ਗਿਆਨ ਹੈ ਕਿਉਂਕਿ ਇਹ **Git ਨੂੰ ਦਸਿਆ-ਰਹਿਤ ਕਰਦਾ ਹੈ** ਅਤੇ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ *ਕਿਉਂ* ਇਸਦੀਆਂ ਕਾਰਵਾਈਆਂ ਇਸ ਤਰ੍ਹਾਂ ਵਰਤਾਓ ਕਰਦੀਆਂ ਹਨ, ਤੁਹਾਡੀ Git ਦੇ ਬਾਰੇ ਸੋਚਣ ਅਤੇ ਵਰਤਣ ਦੀ ਯੋਗਤਾ ਨੂੰ ਡੂੰਘਾ ਕਰਦਾ ਹੈ।

ਮੁੱਖ ਮਾਡਲ — Git ਨੂੰ ਇੱਕ **content-addressable object store** ਦੇ ਰੂਪ ਵਿੱਚ ਚਾਰ object ਕਿਸਮਾਂ ਦੇ ਨਾਲ (blobs ਫਾਈਲ ਸਮੱਗਰੀ ਲਈ, trees ਡਾਇਰੈਕਟਰੀਆਂ ਲਈ, commits snapshots ਲਈ, tags) ਹਰੇਕ ਆਪਣੀ **ਸਮੱਗਰੀ ਦੇ hash** ਦੁਆਰਾ ਪਛਾਨਿਆ ਜਾਂਦਾ ਹੈ — ਉਹ ਬੁਨਿਆਦ ਹੈ ਜਿਸ ਉੱਤੇ ਸਭ ਕੁਝ ਅਰਾਮ ਕਰਦਾ ਹੈ।

ਇਹ ਸਮਝਣਾ ਕਿ **ਇੱਕ commit ਇੱਕ snapshot ਹੈ, diff ਨਹੀਂ** (ਹਰੇਕ commit ਪੂਰੇ ਪ੍ਰਾਜੈਕਟ ਸਥਿਤੀ ਦੀ ਨੁਮਾਇੰਦਗੀ ਕਰਨ ਵਾਲੀ ਇੱਕ ਸਮਪੂਰਨ tree ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ, ਤਬਦੀਲ ਨਹੀਂ ਹੋਈ ਫਾਈਲਾਂ ਕੁਸ਼ਲਤਾ ਨਾਲ ਇੱਕੋ blobs ਨੂੰ ਮੁੜ-ਵਰਤਦੀਆਂ ਹਨ, ਅਤੇ diffs ਗਣਨਾ ਕਰੇ ਜਾਂਦੇ ਹਨ ਨਾ ਕਿ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ) ਇੱਕ ਆਮ ਗਲਤ ਧਾਰਨਾ ਨੂੰ ਸੁਧਾਰਦਾ ਹੈ ਅਤੇ Git ਦੇ snapshot-based ਮਾਡਲ ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ।

**ਇਹ ਦੇਖਣਾ ਕਿ ਇਹ ਕਿਵੇਂ ਫਿੱਟ ਹੁੰਦਾ ਹੈ** (branches ਅਤੇ tags commits ਲਈ ਸਸਤੀ pointers/refs ਦੇ ਰੂਪ ਵਿੱਚ, HEAD ਮੌਜੂਦਾ branch ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ, commits ਆਪਣੇ parents ਦੁਆਰਾ ਚੇਨ ਬੱਧ) ਅੰਦਰਲੀ ਸ਼ਾਨਦਾਰ ਸਪਸ਼ਟਤਾ ਨੂੰ ਪ੍ਰਕਟ ਕਰਦਾ ਹੈ।
esponsibilities ਮੁੱਲਵਾਨ ਤਰੀਕੇ ਨਾਲ, ਇਹ ਸਮਝ **Git ਦੇ ਨਿਰੀਖਣਯੋਗ ਵਿਵਹਾਰ ਦੀ ਵਿਆਖਿਆ ਕਰਦੀ ਹੈ**: ਕਿਉਂ **branches ਹਲਕੇ ਤੋਲ ਦੇ ਹਨ** (ਬਸ ਇੱਕ ਇੱਕ ਛੋਟੀ ਫਾਈਲ ਵਿੱਚ hash, ਫਾਈਲ ਕਾਪੀ ਨਹੀਂ — ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ ਸ਼ਾਖਿੰਗ ਇਤਨੀ ਤੇਜ਼ ਕਿਉਂ ਹੈ), Git ਕੋਲ **integrity** ਹੈ ਕਿਉਂ (content-addressing hash mismatches ਦੁਆਰਾ corruption ਦਾ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ), ਕਿਉਂ **commits ਅਟੱਲ ਹਨ** ਅਤੇ history-rewriting ਕਾਰਵਾਈਆਂ ਜਿਵੇਂ rebase **ਨਵੇ commits ਨਵੇ hashes ਦੇ ਨਾਲ ਬਣਾਉਂਦੀਆਂ ਹਨ** (ਕਿਸੇ ਵੀ ਸਮੱਗਰੀ ਨੂੰ ਬਦਲਣਾ hash ਨੂੰ ਬਦਲਦਾ ਹੈ), ਅਤੇ ਕਿਉਂ Git **ਡੁਪਲੀਕੇਟ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ** (ਇੱਕੋ ਸਮੱਗਰੀ ਇੱਕ ਵਾਰ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ)।

ਇਹ ਡੂੰਘਾ ਮਾਡਲ Git ਨੂੰ ਯਾਦ ਰੱਖਿਆ ਜਾਣ ਵਾਲੀਆਂ ਕਮਾਂਡਾਂ ਦੇ ਸਮੂਹ ਤੋਂ ਇੱਕ ਸਮਝਣਯੋਗ ਸਿਸਟਮ ਵਿੱਚ ਤਬਦੀਲ ਕਰਦਾ ਹੈ, ਗੁੰਝਲਦਾਰ ਕਾਰਵਾਈਆਂ ਬਾਰੇ ਭਰੋਸੇ ਨਾਲ ਸੋਚਣ ਵਿੱਚ ਸਮਰੱਥਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਕਿਉਂਕਿ ਅੰਦਰੂਨੀ object ਮਾਡਲ ਨੂੰ ਸਮਝਣਾ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ Git ਕਿਉਂ ਵਰਤਾਓ ਕਰਦਾ ਹੈ (ਹਲਕੇ ਤੋਲ ਦੀਆਂ branches, ਅਟੱਲ commits, hashes ਨੂੰ rewriting ਤੇ ਤਬਦੀਲ ਕਰਨਾ, integrity) ਅਤੇ ਕਿਸੇ ਨੂੰ Git ਨੂੰ ਵਰਤਣ ਤੋਂ ਸੱਚਮੁੱਚ ਸਮਝਣ ਤੱਕ ਉੱਚਾ ਕਰਦਾ ਹੈ, Git internals ਨੂੰ ਸਮਝਣਾ ਮੁੱਲਵਾਨ senior-level ਗਿਆਨ ਹੈ — ਇੱਕ ਵਿਸ਼ਾ ਜੋ senior ਰੋਲਸ ਲਈ ਉਮੀਦ ਕੀਤੀ ਜਾਣ ਵਾਲੀ ਡੂੰਘਾਈ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ Git ਬਾਰੇ ਭਰੋਸੇ ਨਾਲ ਸੋਚਣ ਲਈ ਮਾਨਸਿਕ ਮਾਡਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਇਸਦੇ ਵਿਵਹਾਰ ਨੂੰ ਦਸਿਆ-ਰਹਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਉন্ਨਤ ਕਾਰਵਾਈਆਂ ਨੂੰ ਰਹਸ਼ਮਈ ਦੀ ਬਜਾਏ ਸਮਝਣਯੋਗ ਬਣਾਉਂਦਾ ਹੈ।