Git 教学工作区 · 速查卡 · 对象模型与三棵树 · 2026-10-16 · 实测环境 git 2.53.0.windows.2

对象模型与三棵树

结论:所有 Git 命令都在动这 4 个对象 + 3 棵树里的某一份数据。 记住「这条命令读的是哪棵树、写的是哪棵树」,status / diff / reset / restore 就不用背了。 下面每一段输出都是在临时目录里真实跑出来的(用固定内容 + 固定时间,哈希可复现)。

1. 四种对象:名字就是内容的哈希

对象存什么不存什么怎么看
blob一个文件的内容(字节串)文件名、路径、权限git cat-file -p <哈希>
tree一层目录:模式 + 类型 + 哈希 + 名字文件内容本身git cat-file -p HEAD^{tree}
commit一个 tree + 父提交 + 作者/提交者 + 信息文件内容、差异(差异是算出来的)git cat-file -p HEAD
tag(附注标签)指向某个对象的带说明的标签不是分支,不会移动git cat-file -p v1.0
commit→ tree(根目录)→ tree(子目录,可再嵌套)→ blob(文件内容)

同一个内容只存一份:两份内容相同、路径不同的文件,共用同一个 blob。反过来说,改一个字节, blob 的哈希就完全不同 —— 这也是「改历史会让所有后续哈希重算」的根源。

亲手验证「内容决定哈希」

以下命令不写任何对象进库(没有 -w),只算哈希;任何机器上结果都一样:

printf 'hello git\n' | git hash-object --stdin
# 8d0e41234f24b6da002d962a26c2495ea16a425f

# 哈希的算法就是 sha1(头部 "blob 字节数\0" + 内容),所以这样算出来一样:
printf 'blob 10\0hello git\n' | sha1sum
# 8d0e41234f24b6da002d962a26c2495ea16a425f  -

printf 'hello git\n' | wc -c
# 10        ← 上面头部里的 10,就是内容字节数

# 库里这个对象确实存在(上面那个哈希在同内容仓库里都成立):
git cat-file -t 8d0e41234f24b6da002d962a26c2495ea16a425f
# blob
git cat-file -p 8d0e41234f24b6da002d962a26c2495ea16a425f
# hello git

2. HEAD / 分支 只是指针

指针本质实测输出
HEAD文件 .git/HEAD,内容通常是一行 ref: refs/heads/<分支>cat .git/HEAD → ref: refs/heads/main
分支文件 .git/refs/heads/<名字>,内容是一个提交哈希git symbolic-ref HEAD → refs/heads/main
当前分支名把上面两步合成一个短名git rev-parse --abbrev-ref HEAD → main
当前提交HEAD 解引用到提交git rev-parse HEAD → 7d5520fbd57cbfe37b1e1049b77d7b3fca0fa964
git branch -v
# * main 7d5520f 首次提交:加入 a.txt 与 b.txt
#   ↑ 分支行显示的是它指向的那个提交,不是"分支里装了提交"

分离头指针(detached HEAD)就是 .git/HEAD 里不再是 ref: …,而直接是一个哈希。 此时提交能建,但没有分支跟着走,切走之后只靠 reflog 才能找回来 —— 详见 撤销与回退速查。

3. 三棵树:同一份内容的三层快照

树存在哪内容是什么看它的命令
工作区 worktree磁盘上你能编辑的目录文件的实际字节cat <文件>
暂存区 index / staging.git/index(二进制文件)下一次提交的清单:模式 + blob 哈希 + 路径 + stage 号git ls-files -s
版本库 repository.git/objects不可变的提交历史git log --oneline

git add 做两件事:把内容写成 blob(objects/),再把「路径 → 哈希」写进 index。 提交时读的是 index,不是工作区 —— 所以「只 add 了一部分」能提交出「部分修改」的提交。

git ls-files -s
# 100644 7bba8c8e64b598d317cdf1bb8a63278f9fc241b1 0	a.txt
# 100644 8d0e41234f24b6da002d962a26c2495ea16a425f 0	b.txt
# 100644 b2a7546679fdf79ca0eb7bfbee1e1bb342487380 0	c.txt
#  ^模式   ^blob 哈希(与 HEAD 里的对比,不同就是"已暂存改动")  ^stage 号  ^路径
# stage 0 = 正常;1/2/3 = 合并冲突时同一路径的三个版本(共同祖先 / 我方 / 对方)
# 平常状态(每一行 = 名字前一个字母,H = cached:该路径存在于暂存区)
git ls-files -t
# H a.txt
# H b.txt
# H c.txt

# 一次真实的 merge 冲突(此时 git status --short 显示 UU a.txt)
git ls-files -t
# M a.txt        ← M = unmerged:同一路径出现三行,每行都标 M
# M a.txt
# M a.txt
# H b.txt        ← 没冲突的文件照旧是 H
# H c.txt
git ls-files -u
# 100644 3ec36c3a902520b45aff4814f8fa7a655d7dfb94 1	a.txt      ← 共同祖先
# 100644 fee5221334681c17b2c76699c04cf0f1941faa6c 2	a.txt      ← 我方(ours)
# 100644 90e9881357254cc4c79318a774c226855edaf797 3	a.txt      ← 对方(theirs)
#   ↑ -u 只列未合并项,把三个 stage 号各自的 blob 摆出来,冲突"三方"到底差在哪一目了然

4. 拆开一次提交:真实输出

临时仓库(A 与 B 两个文件,提交一次),时间设为 2026-10-16T09:00:00+08:00, 所以哈希在同样内容 + 同样作者信息下可复现:

git rev-parse HEAD
# 7d5520fbd57cbfe37b1e1049b77d7b3fca0fa964

git cat-file -t HEAD
# commit

git cat-file -p HEAD
# tree 364a539bf70e4728dcb35e878065f7cd31d9bdf2
# author 学员 <xueyuan@example.com> 1792112400 +0800
# committer 学员 <xueyuan@example.com> 1792112400 +0800
#                              ↑ Unix 时间戳(秒),+0800 是时区
# 首次提交:加入 a.txt 与 b.txt
#   ↑ 提交对象里没有 parent 行 —— 这是第一个提交;第二个提交开始就有 parent

git cat-file -p HEAD^{tree}
# 100644 blob 7bba8c8e64b598d317cdf1bb8a63278f9fc241b1	a.txt
# 100644 blob 8d0e41234f24b6da002d962a26c2495ea16a425f	b.txt
#   ↑ 每条 = 模式 + 类型 + 哈希 + 名字;040000 是子目录(tree)

git ls-tree HEAD
# 与上一条完全相同的四列(ls-tree 是这件事的正式命令)

git cat-file -s 7bba8c8e64b598d317cdf1bb8a63278f9fc241b1
# 14        ← blob 的字节数(内容 "line 1\nline 2\n")
git cat-file -p 7bba8c8e64b598d317cdf1bb8a63278f9fc241b1
# line 1
# line 2

git cat-file -p HEAD^
# fatal: Not a valid object name HEAD^
#   ↑ 唯一一个提交没有父提交,所以 HEAD^ 不存在。这个报错的字面意思就是"没有上一版本"

5. git status --short 两列代号(全部实测)

两列是 XY:X = 暂存区相对 HEAD 变了什么,Y = 工作区相对暂存区变了什么。 三棵树完全一致时没有任何输出(不是 "nothing to commit")。

实测输出怎么造出来的读法
M a.txtprintf 'line 1\nline 2 改动\n' > a.txt只有工作区改了,暂存区没动
M a.txt接着 git add a.txt改动已进暂存区,工作区与暂存区一致
MM a.txtadd 之后再改一次同一个文件暂存区一版、工作区又一版;提交只会提交前一版
?? d.txtprintf 'ddd\n' > d.txt未跟踪:Git 根本不知道它存在
A d.txtgit add d.txt新文件已进暂存区,历史里还没有
D b.txtrm b.txt文件被删,删除这件事还没暂存
D b.txtgit add -A b.txt(或 git rm b.txt)删除已暂存
R c.txt -> e.txtgit mv c.txt e.txt改名已暂存(Git 按内容相似度判定为改名)
UU a.txt两边改了同一处后 git merge冲突未解;工作区文件里已写入 <<<<<<< 标记
git status --short --branch
# ## main            ← 干净时只打印这一行(--branch 额外给一行分支信息)

设了上游之后这一行会带上上游名与领先/落后数。实测(本地一个裸仓库当 origin,用一个分支模拟各种位置):

## main...origin/main                   # 与上游同步
## main...origin/main [ahead 1]         # 本地多 1 个提交
## bd...origin/main [behind 1]          # 上游多 1 个提交(还没合并)
## main...origin/main [ahead 1, behind 1]   # 两边各多 1 个:已分叉,直接 push 会被拒

6. 三种 diff:到底比较哪两棵树

命令比较典型用途
git diff工作区 ↔ 暂存区「我这次还没 add 的改动是什么」
git diff --staged(= --cached)暂存区 ↔ HEAD「我这次 commit 会写进历史的是什么」——提交前看这一条
git diff HEAD工作区 ↔ HEAD「和上个提交比,我现在总共东动了什么」
git diff <提交> -- <路径>该提交 ↔ 工作区,限定路径只看某个文件的历史差异
git diff --stat同 git diff,只给汇总先看规模再看细节

实测(a.txt 第一次改动已 add,随后又改了一次,即 MM 状态):

git status --short
# MM a.txt

git diff                       # 工作区 ↔ 暂存区 → 只看见"第二次"改动
# diff --git a/a.txt b/a.txt
# index 9800b0d..9a53e0e 100644
# --- a/a.txt
# +++ b/a.txt
# @@ -1,2 +1,2 @@
#  line 1
# -line 2 改动
# +line 2 再次改动

git diff --staged              # 暂存区 ↔ HEAD → 只看见"第一次"改动
# diff --git a/a.txt b/a.txt
# index 7bba8c8..9800b0d 100644
# --- a/a.txt
# +++ b/a.txt
# @@ -1,2 +1,2 @@
#  line 1
# -line 2
# +line 2 改动

git diff HEAD                  # 工作区 ↔ HEAD → 两次改动合成一条
# diff --git a/a.txt b/a.txt
# index 7bba8c8..9a53e0e 100644
# @@ -1,2 +1,2 @@
#  line 1
# -line 2
# +line 2 再次改动

git diff --stat
#  a.txt | 2 +-
#  1 file changed, 1 insertion(+), 1 deletion(-)

# 想只撤掉其中一层,见 撤销与回退速查.html:
#   git restore a.txt            撤工作区那层
#   git restore --staged a.txt   撤暂存区那层
#   git restore --source=... -- a.txt   用任意历史版本填回工作区

边界:三棵树一致时 git diff 与 git diff --staged 都无输出; git diff 看不见未跟踪文件 —— 实测:

printf 'brand new\n' > n.txt
git diff
# (无输出:未跟踪文件不在任何一棵树里)

git add -N n.txt        # -N = intent-to-add,只登记"打算加",内容是空的
git status --short
#  A n.txt              ← 注意 X 位置是空格,Y 位置是 A:暂存区里还是没有内容
git diff
# diff --git a/n.txt b/n.txt
# new file mode 100644
# index 0000000..d5a09df
# --- /dev/null
# +++ b/n.txt
# @@ -0,0 +1 @@
# +brand new            ← 现在 diff 能看见它了,便于逐 hunk 挑着 add

7. 一条命令串起三棵树

# 把「怎么走」记住:内容从工作区流向 index,再从 index 流向历史
git add <文件>        # 工作区 → 暂存区(顺带把内容写成 blob)
git commit -m "信息"  # 暂存区 → 历史(写 tree + commit,并把当前分支指针前移一格)
git restore <文件>    # 暂存区 → 工作区(覆盖工作区改动)
git restore --staged <文件>  # HEAD → 暂存区(只撤回 add,不动工作区)
git diff --staged     # 检查"将要提交"的那份清单
git cat-file -p HEAD  # 检查"已经提交"的那份结构

自测

1. git diff --staged 比的是哪两棵树?

对。--staged(=--cached)读的是 index 与 HEAD 的树,所以它显示的就是"这次 commit 会写进历史的东西"。工作区那层留给不带参数的 git diff。

2. git status --short 打印 MM a.txt,提交一次后会写进历史的是哪一版?

对。提交读的是 index。MM 的第二个 M 表示工作区又改了一版,但没 add —— 所以它不会进这次提交,提交完状态还会剩一个 M。

3. 两个路径不同、内容完全相同的文件,在库里占几个 blob?

对。blob 里不含文件名,名字只存在于 tree 的清单里。所以"同一份内容出现在多个目录"只占一份对象存储。