Git ทำงานภายในอย่างไร?

Question

Accepted Answer

ภายในนั้น Git เป็น **content-addressable object store** — มันเก็บทุกอย่างเป็น **object** (blob, tree, commit, tag) ที่ระบุด้วย **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 ที่มีคุณค่า เพราะมัน**ไขความลึกลับของ Git** และอธิบาย*ว่าทำไม*การดำเนินการของมันจึงทำงานเช่นนั้น เพิ่มความสามารถในการให้เหตุผลและใช้ Git อย่างมั่นใจ

โมเดลหลัก — Git เป็น **content-addressable object store** ที่มี object สี่ประเภท (blob สำหรับเนื้อหาไฟล์, tree สำหรับ directory, commit สำหรับ snapshot, tag) แต่ละตัวระบุด้วย **hash ของเนื้อหา** — เป็นรากฐานที่ทุกอย่างวางอยู่บนนั้น

การเข้าใจว่า **commit เป็น snapshot ไม่ใช่ diff** (แต่ละ commit ชี้ไปยัง tree ที่สมบูรณ์ซึ่งแทนสถานะโปรเจกต์ทั้งหมด โดยไฟล์ที่ไม่เปลี่ยนแปลงใช้ blob เดิมซ้ำอย่างมีประสิทธิภาพ และ diff ถูกคำนวณแทนที่จะถูกเก็บ) ช่วยแก้ความเข้าใจผิดที่พบบ่อยและอธิบายโมเดลแบบ snapshot ของ Git

การเห็น**ว่าทุกอย่างประกอบกันอย่างไร** (branch และ tag เป็น pointer/ref ราคาถูกไปยัง commit, HEAD ชี้ไปยัง branch ปัจจุบัน, commit เชื่อมโยงผ่าน parent) เผยให้เห็นความเรียบง่ายอันงดงามที่อยู่เบื้องหลัง

ที่มีคุณค่าที่สุด ความเข้าใจนี้**อธิบายพฤติกรรมที่สังเกตได้ของ Git**: ทำไม **branch จึงเบา** (เป็นเพียง hash ในไฟล์เล็ก ไม่ใช่การคัดลอกไฟล์ — อธิบายว่าทำไมการ branch จึงเร็วมาก), ทำไม Git จึงมี **integrity** (content-addressing ตรวจจับการเสียหายผ่าน hash ที่ไม่ตรงกัน), ทำไม **commit จึงเปลี่ยนแปลงไม่ได้** และการดำเนินการเขียนประวัติใหม่อย่าง rebase จึงสร้าง **commit ใหม่ที่มี hash ใหม่** (การเปลี่ยนเนื้อหาใด ๆ จะเปลี่ยน hash) และทำไม Git จึง **deduplicate** (เนื้อหาที่เหมือนกันถูกเก็บครั้งเดียว)

โมเดลที่ลึกซึ้งนี้เปลี่ยน Git จากชุดคำสั่งที่ท่องจำให้เป็นระบบที่เข้าใจได้ ทำให้สามารถให้เหตุผลกับการดำเนินการที่ซับซ้อนได้อย่างมั่นใจ

เนื่องจากการเข้าใจโมเดล object ภายในอธิบายว่าทำไม Git จึงทำงานเช่นนั้น (branch ที่เบา, commit ที่เปลี่ยนแปลงไม่ได้, hash ที่เปลี่ยนเมื่อเขียนใหม่, integrity) และยกระดับจากการใช้ Git ไปสู่การเข้าใจมันอย่างแท้จริง การเข้าใจการทำงานภายในของ Git จึงเป็นความรู้ระดับ senior ที่มีคุณค่า — เป็นหัวข้อที่สะท้อนความลึกซึ้งที่คาดหวังสำหรับตำแหน่ง senior และให้โมเดลทางความคิดเพื่อให้เหตุผลกับ Git อย่างมั่นใจ ไขความลึกลับของพฤติกรรมและทำให้การดำเนินการขั้นสูงเข้าใจได้แทนที่จะลึกลับ