跳到正文
零到全栈 · 卷 3 · 工程化与版本控制

Git 的心智模型

本合集目录
本章目录

单册说明:本文件是卷 3 的第 1 章,可独立阅读。前置:卷 1 的终端操作、卷 2 第 7 章(三个文件)。本章不背命令,只建一个模型:Git 存的是快照,提交是给整个项目拍照。模型立住了,常用命令只有十来个。

项 内容
所属卷 卷 3 · 工程化与版本控制(第 1 / 7 章)
前置章节 2.7 拆成三个文件,然后撞墙
本章产出 一个初始化好的 dudao 仓库 · 两条有意义的提交 · 一张"我想撤回…"决策表 · 一次误删后的救援记录
对应代码 dudao/(index.html、styles.css、app.js,卷 2 产物;本章新增两条提交,结束时恢复原状)
配图 无(后续统一制图)
读完的判定 看到 git status 的任何一段输出,能说出文件在哪一区、下一句该敲什么

3.1.1 一句话结论:提交是拍照,不是记流水账

新手对 Git 最大的误解是"它记录我每次改了什么"。它真正做的是:每次提交,给整个项目拍一张完整的照片,然后把照片串成一条链。 你看到的"某一行被改了",是 Git 事后拿两张照片对比算出来的,不是它原生存的东西。

这个区别听起来很学究,但它决定了三件事:

你以为 实际 后果
提交只存改动的几行 提交存的是当时全部文件的快照(未变的文件用指针复用上一份) 切到任意历史版本都是完整的,不会"缺文件"
改完文件就等于改完了 改完只是改了工作区,没进仓库 git status 一直红着,关机就没了
git add 是"开始跟踪" git add 是挑选这次要拍进照片的内容 add 完再改,提交里仍是 add 那一刻的版本

真实失败场景:你改完 app.js 的标签配色,git add app.js,顺手又调了两行关键词统计的阈值,然后 git commit。第二天发现统计不对,回看提交——里面根本没有那两行阈值改动。因为拍照的时刻是 add,不是 commit。这个坑我在教学里见过太多次,它不报错,只是安静地少东西。

3.1.2 原理:三个区、一条链、一个指针

① 三个区

Git 把"文件现在处于什么状态"拆成三个位置。所有命令本质上都是在三个区之间搬东西。

区 英文 / 目录 人话 里面是什么
工作区 working tree,就是你用 VS Code 打开的那个文件夹 你正在编辑的可见文件 最新内容,可能没被 Git 管
暂存区 staging area / index,存在 .git/index 下次拍照的取景框 你 git add 进来的那一版内容
本地仓库 repository,存在 .git/objects 已经拍好、编了号的照片库 所有提交,只增不改
(第四个)远程仓库 remote,如 GitHub 上的那份 别人也能看的那份副本 由 push 写入,第 3 章讲
工作区  --git add-->  暂存区  --git commit-->  本地仓库  --git push-->  远程
   ^                     |                        |
   +----- git restore ---+-------- git reset ----+
        (往回搬,方向相反)

记住这张图的箭头方向,比背二十条命令有用。 出问题时你只需要问一句:我要把东西从哪个区搬到哪个区?

② 一次提交到底发生了什么

敲下 git commit -m "...",Git 在毫秒内做了四步:

  1. 算哈希:对暂存区里每个文件的内容算一个 SHA-1(新版本用 SHA-256 亦可),把内容压成 blob 对象存进 .git/objects。内容相同的文件只存一份。
  2. 写目录树:生成一个 tree 对象,记录"这个目录下有哪些文件名、各自指向哪个 blob"。子目录各自是一棵子树。
  3. 写提交对象:commit 对象里只有五样东西——指向根 tree 的指针、指向父提交的指针、作者、时间、提交信息。
  4. 移动指针:把当前分支(比如 main)指向这个新提交,HEAD 跟着分支走。

所以一个提交在磁盘上不是"一段 diff",而是一个两三百字节的文本对象,指向一棵树,树再指向一堆文件内容。同一份没改的文件,在十个提交里只存一次——这就是"快照"不臃肿的原因。

验证一下,这条命令能看到提交对象的原始内容:

git cat-file -p HEAD

形如:

tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904
parent 8c7a00a1f3d5e2b7c9a4d6e8f0a2b4c6d8e0f2a4
author 你的名字 <[email protected]> 1763424000 +0800
committer 你的名字 <[email protected]> 1763424000 +0800

feat: 加入关键词统计

里面没有一行代码。 代码在 tree 指向的地方。这就是"快照"最直接的证据。

③ HEAD 与分支指针

  • 分支就是一个文件,内容是一串提交哈希。.git/refs/heads/main 里就一行 8c7a00a...。
  • HEAD 是"我现在站在哪儿",通常写成 ref: refs/heads/main,也就是"我在 main 上"。
  • 提交时被移动的是分支指针,HEAD 只是跟着它。

由此推出两个反直觉但极其重要的结论:

结论 为什么
删分支不等于删提交 分支只是一张便签,撕掉便签,照片还在仓库里(还能用 reflog 找回)
切分支不是复制文件夹 只是把 HEAD 指向另一张便签,然后把工作区文件换成那张照片的内容

第 2 章会把这套指针玩出花来。现在只要记住:HEAD 决定你站在哪,分支决定你看到哪张照片。

④ git status 怎么读

git status 是本卷最该练熟的命令,它其实是"三个区的对照表"。输出分三段,对应三种状态:

On branch main
Changes to be committed:          ← 暂存区 与 上次提交 不同(下次会进照片)
  (use "git restore --staged <file>..." to unstage)
        modified:   app.js

Changes not staged for commit:    ← 工作区 与 暂存区 不同(改了但没 add)
  (use "git add <file>..." to update what will be committed)
        modified:   styles.css

Untracked files:                  ← 工作区有,但 Git 从没见过
  (use "git add <file>..." to include in what will be committed)
        notes.txt

短格式 git status -s 更省屏幕,但两列字母要会读:左列是暂存区相对上次提交,右列是工作区相对暂存区。

输出 左列含义 右列含义 人话
M app.js 未变 已修改 改了,没 add
M app.js 已修改 未变 add 了,可以提交
MM app.js 已修改 已修改 add 之后又改了,提交只会带上 add 的那版
A store.js 新增已暂存 未变 新文件已进取景框
?? notes.txt — — 未跟踪,Git 完全不管它
D old.css 删除已暂存 未变 删除了,且这个删除会被提交

MM 这一行是本卷最值钱的一行。 看到它就说明你的暂存区和工作区已经分叉了,直接 commit 会漏掉后半段改动。

⑤ 撤销三板斧:分别撤什么

这是全章最需要背下来的表。用错 reset --hard 会真丢代码,而 revert 和 restore 几乎不会。

我想撤回… 命令 撤的是哪一层 内容会不会没
某个文件没 add 的改动 git restore app.js 工作区 ← 暂存区 会没(这正是目的)
已经 add,想退出暂存区 git restore --staged app.js 暂存区 ← HEAD 不会,改动留在工作区
刚提交,想补文件 / 改信息 git commit --amend 改写最后一条提交 不会(未推送才可用)
刚提交,想撤销但保留改动 git reset --soft HEAD~1 只移动分支指针 不会,改动回到暂存区
刚提交,想撤销并重新挑文件 git reset HEAD~1 指针 + 暂存区(mixed 是默认) 不会,改动回到工作区
刚提交,连改动一起扔掉 git reset --hard HEAD~1 指针 + 暂存区 + 工作区 会没(还能靠 reflog 抢救)
已推送、别人也有的提交 git revert <哈希> 新增一条"反向提交" 不会,历史不被改写
误操作 reset 之后 git reflog 找到旧哈希,再 git reset --hard <哈希> 把指针搬回去 通常能救回来

一句话记忆:restore 管文件,reset 管指针,revert 管历史。 只要提交已经离开你的电脑,就只该用 revert——因为在别人的仓库里改写历史,等于让所有人的记录对不上。

3.1.3 动手:给「读到」建第一个仓库

确认你在卷 2 的 dudao/ 目录里,且里面是三个文件:

pwd
ls

形如:

/c/Users/you/code/dudao
app.js  index.html  styles.css

第 1 步:初始化

git init

形如:

Initialized empty Git repository in C:/Users/you/code/dudao/.git/

此时 ls -a 会多出一个 .git/。这个目录就是整个仓库,删了它历史就没了;反过来,只要它在,你的提交就还在。

不同 Git 版本的默认分支名不一样(master 或 main)。统一成 main,跟 GitHub 默认保持一致:

git branch -M main

第 2 步:看一次"什么都没有"的状态

git status

形如:

On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        app.js
        index.html
        styles.css

nothing added to commit but untracked files present (use "git add" to track)

注意 No commits yet:仓库建好了,但一张照片都没拍。

第 3 步:第一次提交

git add index.html styles.css app.js
git status -s

形如:

A  app.js
A  index.html
A  styles.css

三个 A 在左列,说明已进暂存区。提交:

git commit -m "chore: 导入卷2的三个文件"

形如:

[main (root-commit) 1a2b3c4] chore: 导入卷2的三个文件
 3 files changed, 214 insertions(+)
 create mode 100644 app.js
 create mode 100644 index.html
 create mode 100644 styles.css

root-commit 表示这是第一条提交,没有父提交。214 insertions 是三个文件加起来的行数——快照第一次拍,所以全是"新增"。

第 4 步:第二次提交,并亲手感受三区

先改点真东西:在 app.js 里给标签栏加一个"全部"按钮的选中态。改完立刻看状态:

git status -s
 M app.js

左空右 M:改了,没 add。看差异(这一步只是"对比两张照片",不改变任何东西):

git diff

形如:

diff --git a/app.js b/app.js
index 3f2a1c9..b7e4d20 100644
--- a/app.js
+++ b/app.js
@@ -41,6 +41,9 @@ function renderTags() {
-    btn.className = 'tag';
+    btn.className = tag === state.activeTag ? 'tag tag--active' : 'tag';

- 是旧行,+ 是新行。git diff 不带参数 = 工作区 vs 暂存区;git diff --staged = 暂存区 vs 上次提交。 两个都看一遍,你就永远知道自己在提交什么。

接着 add,然后再改一行(故意制造 MM):

git add app.js
# 再随手改一行注释
git status -s
MM app.js

现在提交,然后看提交里到底有什么:

git commit -m "feat: 标签栏增加选中态"
git show --stat HEAD

形如:

commit 7d3f9a2... (HEAD -> main)
Author: 你的名字 <[email protected]>
Date:   ...

    feat: 标签栏增加选中态

 app.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

只有 3 行变化,说明刚才那次"随手改的注释"没有被拍进去——它还在工作区,git status 依旧显示 M app.js。这就是 3.1.1 那个失败场景的现场。

第 5 步:读历史

git log --oneline

形如:

7d3f9a2 (HEAD -> main) feat: 标签栏增加选中态
1a2b3c4 chore: 导入卷2的三个文件

--oneline 每行一条:短哈希 + 提交信息。括号里的 HEAD -> main 告诉你"现在站在这条提交上,且 main 指着它"。

再加两个常用参数,看清结构:

git log --oneline --graph --all
git log -1 --stat

第 6 步:演一次事故,再救回来

先把当前状态备份成一个标签,方便你随时对照:

git tag before-accident

然后故意犯错——把工作区完全退回上一条提交:

git reset --hard HEAD~1

形如:

HEAD is now at 1a2b3c4 chore: 导入卷2的三个文件

git status 现在干净了,app.js 里的选中态代码也没了——连同刚才那行没提交的注释一起没了。--hard 不区分"提交过的"和"没提交的",它把三个区全部对齐到目标提交。这就是它的威力:没有确认,没有回收站。

救援:

git reflog

形如:

1a2b3c4 (HEAD -> main, tag: before-accident) HEAD@{0}: reset: moving to HEAD~1
7d3f9a2 HEAD@{1}: commit: feat: 标签栏增加选中态
1a2b3c4 HEAD@{2}: commit (initial): chore: 导入卷2的三个文件

HEAD@{1} 就是被扔掉的那条提交。搬回来:

git reset --hard HEAD@{1}
HEAD is now at 7d3f9a2 feat: 标签栏增加选中态

代码回来了。reflog 记录的是"HEAD 去过哪儿",是本地的、只增的日志,默认保留 90 天。 它不是万能——如果对象被垃圾回收(git gc 且超过保留期),或者你从没提交过,就真没了。所以"先提交,再折腾"是唯一可靠的保险。

3.1.4 三个坑

坑 1:fatal: not a git repository

症状:命令明明没错,Git 就是说找不到仓库。

fatal: not a git repository (or any of the parent directories): .git

成因:你在 dudao/ 里 init 了,但终端当前在上一级(比如 ~/code),或者你在 dudao/js/ 里而仓库根本没建到那儿。Git 会向上找 .git,找到就用;找不到就报这句。

修法:先 pwd 看在哪,再 ls -a 看有没有 .git。不要在错误的层级"再来一次 git init"——那会造出嵌套仓库,之后 git status 会把整个子仓库当成一个陌生目录,症状更怪。

坑 2:git add . 之后没东西可提交

症状:文件明明在文件夹里,git add . 也执行了,git commit 却说:

nothing to commit, working tree clean

成因:三种可能,按概率排——① 文件被 .gitignore 忽略了(比如 dist/、.env);② 那是个空目录,Git 只跟踪文件,不跟踪目录;③ 文件在子目录里,而你在另一层执行。

修法:让 Git 自己告诉你被哪条规则拦了:

git check-ignore -v dist

形如:

.gitignore:4:dist/	dist

左边是规则所在文件与行号。空目录就放一个 .gitkeep 占位;层级不对就 cd 到正确位置。

坑 3:把不该提交的东西提交了(尤其是密钥)

症状:git status 里出现 .env,或者提交历史里已经躺着一段数据库密码。它不会报错,只会在某天你公开仓库时变成事故。

成因:git add . 是"把当前目录下所有未忽略的文件都放进取景框",它不理解哪个文件敏感。

修法:分两种情况。

还没提交(只是在暂存区):

git restore --staged .env

已经提交、还没推送:把文件从这次提交里摘掉,再改写这条提交:

git rm --cached .env
git commit --amend --no-edit

已经推送:改历史不够,必须换密钥。因为只要推上去过,它就可能被缓存、被抓取、被告警系统存档。正确顺序是先去服务商后台吊销并重新生成,再用 git filter-repo 清历史,最后强推并通知所有协作者重新克隆。第 3 章会把这条流程走完整。

一句话预防:在第一次 git add 之前就写好 .gitignore。顺序反了,代价是十倍。

本章验收

  • 能画出工作区 / 暂存区 / 仓库三区,并标出 add、commit、restore、reset 的方向
  • 能解释"提交里没有 diff",并说出 git cat-file -p HEAD 里那五行各是什么
  • 看到 MM、 M、M 、?? 四种状态,能立刻说出下一步命令
  • 能在不查资料的情况下,为"撤销一个已推送的提交"选对命令(revert)
  • 亲手做过一次 reset --hard,并用 git reflog 救回
  • 仓库里有两条以上提交,git log --oneline 能读出先后关系

自测

Q1:你 git add app.js 之后又改了 5 行,然后 git commit。这 5 行在哪?

看答案 还在工作区,没进这次提交。暂存区保存的是 `add` 那一刻的内容,`commit` 拍的是暂存区,不是当前文件。`git status` 会显示 `MM`,`git diff` 能看到这 5 行,`git diff --staged` 看不到。要把它们带上,得再 `git add app.js` 一次(或 `git commit --amend`)。

Q2:同事让你撤销一个已经合并进 main 的提交,你为什么不该用 git reset --hard?

看答案 因为 `reset` 是把分支指针往回搬,属于改写历史。`main` 已经在别人机器上,你一强推,别人的本地历史和远端就分叉,他们下次 `pull` 会得到一堆看似"重复"的提交或直接冲突。正确做法是 `git revert <哈希>`:它生成一条新提交,内容是"把那次改动反向应用一遍",历史继续向前,所有人都能安全 `pull`。

Q3:git reset --hard 之后发现删错了,第一件该做的事是什么?为什么不是重新写代码?

看答案 先 `git reflog`,找到被丢掉的那条提交哈希(通常是 `HEAD@{1}`),再 `git reset --hard <哈希>`。因为提交对象还在 `.git/objects` 里,只是没有分支指向它;reflog 保留了 HEAD 的移动轨迹,默认 90 天内都能找回来。重写代码不仅慢,还会丢掉当时的准确状态。只有当改动从未提交过时,才真的无法恢复。

下一步

仓库有了,历史也有了。接下来学一件让 Git 真正好用的事:在不打扰 main 的前提下开一条岔路,改完再合回来——以及合不回来时怎么办。

→ 卷3-02-分支合并与冲突.md