Git 内部原理与底层命令

开场:Git 本质上是什么

前面几课都在用命令:git add、git commit、git switch、git rebase。 这一课停下来,拆开 .git 目录,看这些命令到底在操作什么。

先给一个可能反直觉的定义:Git 本质上是一个“内容寻址的文件系统”,版本控制只是它上面的一个应用。

普通文件系统按文件名找文件:你给路径,它返回内容。Git 反过来,按内容找东西: 你把一段内容交给它,它算出一个哈希当“地址”,以后用这个哈希取回内容。文件名在 Git 里不是主键,哈希才是。

这个设计带来几个直接结果:

  • 相同内容只存一份,不管文件名是什么、在哪条分支上;

  • 内容改一个字节,哈希全变;

  • 哈希是内容的指纹,可以用来校验完整性;

  • 仓库可以完整校验,不会悄悄损坏。

理解这一点,后面的一切都顺了。

四种对象

Git 仓库里所有东西,最终都是四种对象之一:blob、tree、commit、tag。 它们不是抽象概念,是实实在在存在 .git/objects/ 下的文件,文件名就是内容的哈希。

先准备一个空仓库:

mkdir git-internals
cd git-internals
git init

blob:只存文件内容

创建一个文件,把内容交给 Git 存成 blob:

echo "hello git" > hello.txt
git hash-object -w hello.txt
8d0e41234f24b6da002d962a26c2495ea16a425f

这一串哈希就是 blob 的地址。-w 表示真正写入对象库;不加只计算哈希,不存。 查看这个对象:

git cat-file -t 8d0e412
blob git cat-file -p 8d0e412
hello git

-t 显示类型,-p 显示内容。

blob 不存文件名

这一点最容易忽略:blob 只存文件内容,不存文件名、不存权限。 文件名和权限是 tree 管的。所以内容相同的两个文件,哪怕名字完全不同,也共享同一个 blob。

验证一次“内容寻址”:改文件名,内容不变:

cp hello.txt hello-copy.txt
git hash-object hello-copy.txt
8d0e41234f24b6da002d962a26c2495ea16a425f

哈希一样。因为内容一样,Git 只存一份。

tree:目录快照

blob 只有内容,没有名字。tree 把“文件名”和“blob 哈希”连起来,相当于一个目录快照。 它的一行格式是:<模式> <类型> <哈希>\t<文件名>。

手动造一个 tree:

printf '100644 blob 8d0e41234f24b6da002d962a26c2495ea16a425f\thello.txt\n' | git mktree
b7f5c9e3a2d14e8f6c0b9a7d5e3f1c2b8a6d4e0f

查看它:

git cat-file -p b7f5c9e
100644 blob 8d0e41234f24b6da002d962a26c2495ea16a425f hello.txt

模式的含义:

模式

含义

100644

普通文件

100755

可执行文件

040000

子目录,指向另一个 tree

120000

符号链接

tree 可以嵌套:子目录的 tree 哈希出现在父 tree 里,类型写 tree。 根 tree 就是一次提交的完整目录结构。

commit:一次快照

commit 对象指向一个 tree,再加上父提交、作者、时间、提交信息。 它不直接存文件内容,只存一个 tree 的哈希。

先用普通方式提交一次,再拆开看:

git add hello.txt
git commit -m "add hello"
git log --oneline
a1b2c3d add hello

查看这次提交:

git cat-file -p a1b2c3d
tree 4f2a8c1d9e6b3a7f5c2d8e1b4a9f6c3d7e2b5a8f
parent 6c2a18f...
author Zhang San <zhangsan@example.com> 1794735688 +0800
committer Zhang San <zhangsan@example.com> 1794735688 +0800 add hello

commit 非常轻量:只有一棵 tree 的哈希、一个父提交哈希、两组身份时间、一段文字。没有文件内容,没有差异。

tag:带注释的标签

轻量标签只是一个引用,直接指向 commit。带注释的标签是一个 tag 对象,有自己的哈希和内容:

git tag -a v1.0 -m "第一个版本" git cat-file -t v1.0
tag git cat-file -p v1.0
object a1b2c3d...
type commit
tag v1.0
tagger Zhang San <zhangsan@example.com> 1794735700 +0800 第一个版本

-a 才会创建 tag 对象;不带 -a 只创建一个 ref,指向 commit,没有额外的对象。

一张图串起来

commit ──▶ tree ──▶ blob │ │ │ └──▶ tree ──▶ blob │ └──▶ parent commit

每次提交,Git 创建新的 tree 和 commit;没变的内容复用已有的 blob/tree。 这就是“相同内容只存一份”在对象层面的样子。

哈希:内容寻址的机制

Git 默认用 SHA-1 计算对象哈希。计算方式是:对 "类型 长度\0内容" 做 SHA-1, 类型是 blob、tree、commit、tag,长度是内容的字节数。

验证一下,用标准输入手动算一个 blob 的哈希:

echo "hello git" | git hash-object --stdin
8d0e41234f24b6da002d962a26c2495ea16a425f

和前面 git hash-object -w hello.txt 的结果一样,因为文件内容相同。

哈希为什么重要:

作用

说明

完整性校验

内容改一个字节,哈希全变,Git 能发现对象损坏

去重

相同内容只存一次,不管出现在多少分支、多少次提交里

快速比较

比哈希比比较文件内容快得多

历史不可篡改

改历史提交内容,哈希变,后面所有提交连锁变化

关于 SHA-1 碰撞:理论上存在不同内容算出相同哈希的可能,Git 社区在推进 SHA-256。 日常使用中碰撞概率极低,而且 Git 有额外防护。知道有这回事即可。

引用、HEAD 和分支

对象是内容,但人不可能记一堆哈希。引用(ref)就是给人看的名字:名字 → 哈希的映射。

refs 目录

find .git/refs -type f
.git/refs/heads/main
.git/refs/tags/v1.0

打开分支文件:

cat .git/refs/heads/main
a1b2c3d4e5f6...

分支本质上就是一个文件,里面存着一个 commit 哈希。 创建分支就是写一个 41 字节的文件,删除分支就是删一个文件,所以几乎零成本。

git branch 列的就是 .git/refs/heads/ 下的文件。

有时候 find .git/refs 看不到东西,因为 Git 会把 refs 打包进 .git/packed-refs。git show-ref 能统一查看:

git show-ref
a1b2c3d... refs/heads/main
a1b2c3d... refs/tags/v1.0

HEAD

.git/HEAD 是一个特殊文件,内容通常是一行引用:

cat .git/HEAD
ref: refs/heads/main

意思是“HEAD 指向 main 分支的引用”。HEAD 本身不存哈希,它存“我在哪个分支上”。 git switch feature 改的就是这个文件,内容变成 ref: refs/heads/feature。

detached HEAD

如果 HEAD 里直接是一个 commit 哈希,而不是 ref: ...,就是分离头指针:

cat .git/HEAD
8d0e41234f24b6da002d962a26c2495ea16a425f

进入方式:

git switch --detach HEAD~1

危险在于:HEAD 没有指向任何分支。在这里提交,新提交不属于任何分支;切回别的分支后,这些提交可能“丢失” (虽然能用 reflog 找回)。

但 detached HEAD 不是错误,是“临时查看某个提交”的正常状态。查看历史、跑测试、临时实验都可以。要开发就开分支:

git switch -c new-branch

index(暂存区)

.git/index 是暂存区的二进制数据。它记录“下一次提交要包含哪些文件、每个文件对应哪个 blob”。

git add 做两件事:

  1. 把文件内容存成 blob(如果内容已存在,复用);

  2. 更新 .git/index,记录“这个路径现在对应这个 blob”。

理解 index,就理解了前面几课这些比较:

命令

比较的是

git status

工作区 vs index vs HEAD 的 tree

git diff

工作区 vs index

git diff --staged

index vs HEAD

用底层命令复现一次提交

现在不用 git add / git commit,纯手工造一次提交,体会每一步在做什么。 先确保当前有至少一次提交(HEAD 有效),否则 -p HEAD 会失败。

# 1. 存 blob
echo "manual commit" > manual.txt
BLOB=$(git hash-object -w manual.txt) # 2. 造 tree
TREE=$(printf "100644 blob $BLOB\tmanual.txt\n" | git mktree) # 3. 造 commit(以当前 HEAD 为父提交)
COMMIT=$(echo "manual commit" | git commit-tree $TREE -p HEAD) # 4. 把 main 分支移到新 commit
git update-ref refs/heads/main $COMMIT # 5. 同步工作区和 index
git reset --mixed HEAD

然后 git log --oneline,手工造的提交出现在历史里。

这个实验的意义:git add 和 git commit 不是魔法,只是把这四步包装起来了。 每一步你都能在 .git 目录里找到对应文件。

常用底层命令小结:

命令

作用

git hash-object -w

存 blob

git cat-file -t/-p

查看对象类型 / 内容

git mktree

创建 tree

git ls-tree

列出 tree 内容

git commit-tree

创建 commit

git update-ref

更新引用

git rev-parse

解析引用为哈希

git show-ref

列出所有引用

git rev-parse 很实用,能把各种引用写法解析成完整哈希:

git rev-parse HEAD
git rev-parse main
git rev-parse HEAD~2

这一课解释了前面哪些“为什么”

问题

答案

为什么分支几乎零成本?

分支就是一个存哈希的文件。创建分支 = 写一个 41 字节的文件。

为什么 rebase 会改哈希?

rebase 重新创建 commit 对象。父提交变了,commit 内容变了,哈希自然变。

为什么相同文件只存一份?

内容寻址 + blob 去重。不管多少分支、多少次提交,相同内容只存一个 blob。

为什么 detached HEAD 危险?

HEAD 不指向分支,新提交没有分支引用指向它。切走后只能靠 reflog 找回。

为什么 .git 不能手动改?

对象、引用、index 之间有严格的哈希和格式关系,手改容易损坏。用命令改,Git 会保证一致性。

为什么 git status 能知道文件状态?

它比较工作区文件、.git/index、HEAD 的 tree 三者的哈希。