Git 在内部是如何工作的？

Question

Git 在内部是如何工作的？

Accepted Answer

在内部，Git 是一个**内容寻址对象存储**——它将所有内容都存储为**对象**（blobs、trees、commits、tags），通过它们的 **SHA-1 哈希**来标识。理解这个模型能够揭开 Git 的神秘面纱，并解释为什么它的操作表现得如此。

## Git 是一个内容寻址对象存储

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

## 一个提交是一个快照，而不是一个差异

```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 的内部工作原理是有价值的高级水平知识，因为它**揭开了 Git 的神秘面纱**，解释了为什么它的操作会如此表现，加深了你对 Git 的推理和自信使用能力。

核心模型——Git 作为一个**内容寻址对象存储**，有四种对象类型（blobs 用于文件内容，trees 用于目录，commits 用于快照，tags 用于标记），每个都通过**其内容的哈希**标识——这是其他一切的基础。

理解**一个提交是一个快照，而不是一个差异**（每个提交指向一个代表完整项目状态的树，未改变的文件高效地重用相同的 blobs，差异是计算得出的而不是存储的）纠正了一个常见误解，解释了 Git 的基于快照的模型。

看到**它是如何组合在一起的**（分支和标记作为提交的廉价指针/引用，HEAD 指向当前分支，提交通过父链接）揭示了其下的优雅简洁性。

最有价值的是，这种理解**解释了 Git 的可观察行为**：为什么**分支很轻量级**（只是一个小文件中的哈希，而不是文件副本——解释了为什么分支如此快速），为什么 Git 有**完整性**（内容寻址通过哈希不匹配检测损坏），为什么**提交是不可变的**，历史重写操作如 rebase 创建**带有新哈希的新提交**（改变任何内容会改变哈希），以及为什么 Git **去重**（相同内容只存储一次）。

这个更深层的模型将 Git 从一组记忆中的命令转变为一个可理解的系统，使得能够自信地推理复杂的操作。

由于理解内部对象模型解释了 Git 为什么会这样表现（轻量级分支、不可变提交、重写时的哈希改变、完整性），并将人从使用 Git 提升到真正理解它，理解 Git 内部工作原理是有价值的高级水平知识——这个主题反映了高级角色所期望的深度，并提供了自信推理 Git 的心智模型，揭开其行为的神秘面纱，使高级操作变成可理解的而不是神秘的。