Bagaimana Git berfungsi secara dalaman?

Question

Accepted Answer

Secara dalaman, Git ialah **stor objek content-addressable** — ia menyimpan segala-galanya sebagai **objek** (blob, tree, commit, tag) yang dikenal pasti melalui **hash SHA-1**. Memahami model ini menghilangkan misteri Git dan menjelaskan mengapa operasinya berkelakuan sebagaimana yang berlaku.

## Git ialah stor objek content-addressable

```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 ialah snapshot, bukan 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.
```

## Bagaimana ia bersatu

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

## Mengapa ini menjelaskan kelakuan 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)
```

## Mengapa ia penting

Memahami cara Git berfungsi secara dalaman ialah pengetahuan peringkat senior yang bernilai kerana ia **menghilangkan misteri Git** dan menjelaskan *mengapa* operasinya berkelakuan sedemikian, memperdalam keupayaan anda untuk menaakul dan menggunakan Git dengan yakin.

Model teras — Git sebagai **stor objek content-addressable** dengan empat jenis objek (blob untuk kandungan fail, tree untuk direktori, commit untuk snapshot, tag) yang setiap satu dikenal pasti melalui **hash kandungannya** — ialah asas yang menjadi landasan segala-galanya.

Memahami bahawa **commit ialah snapshot, bukan diff** (setiap commit menunjuk ke tree lengkap yang mewakili keadaan penuh projek, dengan fail yang tidak berubah menggunakan semula blob yang sama secara cekap, dan diff dikira berbanding disimpan) membetulkan salah faham yang biasa dan menjelaskan model berasaskan snapshot Git.

Melihat **bagaimana ia bersatu** (cawangan dan tag sebagai penunjuk/ref murah kepada commit, HEAD menunjuk ke cawangan semasa, commit dirangkai melalui parent) mendedahkan kesederhanaan yang elegan di sebaliknya.

Yang paling bernilai, pemahaman ini **menjelaskan kelakuan Git yang boleh diperhatikan**: mengapa **cawangan ringan** (hanyalah hash dalam fail kecil, bukan salinan fail — menjelaskan mengapa percabangan begitu pantas), mengapa Git mempunyai **integriti** (content-addressing mengesan kerosakan melalui ketidakpadanan hash), mengapa **commit tidak boleh diubah** dan operasi penulisan semula sejarah seperti rebase mencipta **commit baharu dengan hash baharu** (mengubah mana-mana kandungan mengubah hash), dan mengapa Git melakukan **deduplikasi** (kandungan yang sama disimpan sekali sahaja).

Model yang lebih mendalam ini mengubah Git daripada satu set arahan yang dihafal menjadi satu sistem yang boleh difahami, membolehkan penaakulan yang yakin tentang operasi yang kompleks.

Memandangkan memahami model objek dalaman menjelaskan mengapa Git berkelakuan sedemikian (cawangan ringan, commit tidak boleh diubah, perubahan hash semasa penulisan semula, integriti) dan meningkatkan seseorang daripada hanya menggunakan Git kepada benar-benar memahami Git, memahami dalaman Git ialah pengetahuan peringkat senior yang bernilai — satu topik yang mencerminkan kedalaman yang dijangka untuk peranan senior dan menyediakan model mental untuk menaakul Git dengan yakin, menghilangkan misteri kelakuannya dan menjadikan operasi lanjutan boleh difahami berbanding misteri.