远程协作与团队工作流

Github

如果你想把你的项目包括你的版本控制推送到网上,托管你的源码的就是远程仓库,最常用的就是Github。

第一次推送到 GitHub 仓库

现在已经不建议用密码登录

从 2021 年起,git push 在 “Password” 一栏填 GitHub 登录密码会直接失败。 今天要“配置账号”,实际是用 Personal Access Token(PAT)代替密码,或者改用 SSH 密钥。 下面以 PAT + HTTPS 为主线,完整走一遍从零到推送成功。

第一步:在 GitHub 上创建一个空仓库

登录 GitHub,点右上角 “+” → “New repository”。

关键:不要勾选 README、.gitignore、License,保持完全空白。 否则远程仓库会自带一个提交,你本地第一次 push 时会因为两边历史不一致而被拒绝,多出一个不必要的合并步骤。

创建完成后,记下仓库的 HTTPS 地址:

https://github.com/你的用户名/你的仓库名.git

第二步:在 GitHub 上生成 Personal Access Token(代替密码)

这是“配置账号”的核心步骤。GitHub 的密码只用于网页登录,不用于 Git 命令行。

  1. 打开 https://github.com/settings/tokens。

  2. 点 “Generate new token”,选择 Fine-grained token(推荐)或 Classic。Fine-grained 可以只授权给一个仓库,更安全。

  3. 给 token 起个名字,设置过期时间(90 天是常见选择)。

  4. 权限:如果选 Fine-grained,在 “Repository permissions” 里找到 Contents,设为 Read and write,这是推送文件内容所需的最小权限;如果选 Classic,勾选 repo 即可。

  5. 点 “Generate token”,立刻复制生成的 token。它只显示一次,离开页面后就再也看不到了。

把它想象成一把“专用于 Git 推送的临时密码”。

第三步:本地仓库接上远程地址

进入你的项目文件夹。如果还没有初始化 Git,先做一次初始提交:

git init
git add .
git commit -m "Initial commit"
git branch -M main

然后告诉本地仓库,远程在哪里:

git remote add origin https://github.com/你的用户名/你的仓库名.git #这里origin只是设置远程仓库的名字,是你自己定义的

验证一下:

git remote -v #查看所有对应仓库的名字
origin	https://github.com/你的用户名/你的仓库名.git (fetch)
origin	https://github.com/你的用户名/你的仓库名.git (push)

应该看到两行,分别对应 fetch 和 push 的地址。

第四步:手动执行第一次 push

现在敲下第一次推送命令:

git push -u origin main #推送到origin的main分支

-u 的意思是 --set-upstream:把本地 main 和远程 origin/main 关联起来。 之后在这个分支上,直接 git push 就够了,不用每次都写 origin main。

接下来 Git 会向你索要凭据。这才是“配置账号密码”真正发生的地方:

Username for 'https://github.com': 你的GitHub用户名
Password for 'https://你的用户名@github.com':
  • Username:填你的 GitHub 登录名。

  • Password:不要填登录密码,把刚才复制的 PAT 粘贴进去。

在终端里粘贴时,屏幕上不会显示任何字符(连星号都没有),这是正常的,粘贴完直接回车即可。 如果 token 和权限都正确,会看到类似这样的输出:

Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Writing objects: 100% (3/3), 1.2 KiB | 1.2 MiB/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/你的用户名/你的仓库名.git * [new branch] main -> main
branch 'main' set up to track 'origin/main'.

最后两行说明:main 已作为新分支推送到远程,并且本地 main 已经跟踪了 origin/main。

第五步:验证

刷新 GitHub 仓库页面,文件应该已经出现。本地也可以确认关联状态:

git branch -vv
* main 4e0b284 [origin/main] Initial commit

main 后面带着 [origin/main],说明跟踪关系已建立。 之后你在本地 commit 后,直接运行 git push 即可,不需要再写远程名和分支名。

每次都要输入 token 吗

不一定。如果系统安装了 Git Credential Manager(Git for Windows 默认自带,macOS 的 osxkeychain 承担类似角色), 第一次输入 token 后它会被缓存起来,后续推送通常不再询问。缓存失效或 token 过期时才需要重新输入。

替代方案:SSH 密钥(一次配置,长期免密)

不想管理 token 的过期和权限,可以用 SSH,尤其适合自己长期使用的电脑。大致流程:

ssh-keygen -t ed25519 -C "你的邮箱"

一路回车接受默认路径。然后把公钥 ~/.ssh/id_ed25519.pub 的内容复制到 GitHub 的 Settings → SSH and GPG keys → New SSH key。测试:

ssh -T git@github.com

看到 successfully authenticated 就说明配置成功。然后把远程地址改成 SSH 形式:

git remote set-url origin git@github.com:你的用户名/你的仓库名.git

之后 git push 就不再需要输入 token 了。

一句话收束:今天不存在“填 GitHub 登录密码就能推送”这回事;第一次推送的本质是 创建一个 PAT 当密码用,或者 配置一对 SSH 密钥建立信任, 然后用 git push -u origin main 把本地 main 和远程对齐。对齐一次之后,后续推送就只剩 git push 了。

常见命令

当前仓库认识哪些远程:

git remote -v
# 一行都没有 —— 这个仓库还不认识任何别的仓库

把地址交给仓库,并给它起个短名字:

git remote add origin https://github.com/你的用户名/你的仓库名.git
git remote -v
origin	https://github.com/你的用户名/你的仓库名.git (fetch)
origin	https://github.com/你的用户名/你的仓库名.git (push)

每个远程打两行:(fetch) 是读取地址,(push) 是写入地址,通常相同。 origin 是名字,后面那串是地址。

名字本身没有特殊含义,换一个名字一切照常,连 git branch -vv 方括号里的名字都跟着换:

git remote rename origin he
git remote -v
he	https://github.com/你的用户名/你的仓库名.git (fetch)
he	https://github.com/你的用户名/你的仓库名.git (push) git branch -vv
* main 4e0b284 [he/main] add stock clamps git remote rename he origin

地址一个字没动。方括号从 [origin/main] 变成 [he/main], 改回名字之后又变回来。

clone

git clone https://github.com/你的用户名/你的仓库名.git

它先建一个空仓库,再把远程仓库的内容和引用全部搬过来,最后帮你检出默认分支、配好跟踪关系。 默认使用origin作为仓库名字

名字重了会被拦,不会悄悄覆盖:

git remote add origin https://github.com/你的用户名/你的仓库名.git
error: remote origin already exists.

origin/main 这条线是谁记下来的

执行完 git push -u 或 git clone 之后,本地会多出一条没有工作区的分支:

git branch -r origin/main git branch -a
* main remotes/origin/main

origin/main 不是远程仓库里的 main,而是本地的一张“缓存纸条”: 上一次和服务器对过之后,对面的 main 停在哪。它的正名叫远程跟踪分支(remote-tracking branch)。它是你本地对远程 main 分支最后一次已知位置的缓存。 它存在一个普通文件里:

ls .git/refs/remotes/origin
main cat .git/refs/remotes/origin/main
4e0b2847009a4e2d38934f2b37f582e96c6c01cf

这个文件就是全部。git branch -r 列的是目录里存了哪几个名字,cat 出来的是它记的那次提交。 路径里的 origin 来自远程名,斜杠换成目录层级。

这条线是怎么被记下来的

它由 git fetch、git pull、git push、git clone 自动更新, 规则写在 .git/config 里那一行 fetch = +refs/heads/*:refs/remotes/origin/*: 把对面 refs/heads/ 下的每个分支,映射到本地 refs/remotes/origin/ 下的同名文件。 你不需要手动建它。

关键点:它是本地文件,不问服务器就一动不动。别人推了新提交,你这边这张纸条不会自动更新。 想看服务器此刻的真实值,得直接问它:

git ls-remote origin main
4e0b2847009a4e2d38934f2b37f582e96c6c01cf	refs/heads/main

这一次两边一样。等别人推过、这边没抓,右边就会先走一步——下面那节讲它闹出的麻烦。

第二份仓库 clone 下来,纸条和上游都是现成的:

git clone https://github.com/你的用户名/你的仓库名.git lisi
Cloning into 'lisi'...
done. git remote -v
origin	https://github.com/你的用户名/你的仓库名.git (fetch)
origin	https://github.com/你的用户名/你的仓库名.git (push) git branch -vv
* main 4e0b284 [origin/main] add stock clamps

一条 clone 同时做了三件事:

动作

结果

把对象和历史搬过来

.git/objects/ 里有了对方全部提交

建好 origin

git remote -v 有地址

给 main 写上上游

git branch -vv 方括号里有 [origin/main]

方括号和 .git/refs/remotes/ 那张纸条一起出现,所以这份克隆第一次就能 git push, 不用再敲 -u。

别人push了远程仓库,但你却不知道

当你在另一个同git项目仓库了里加一个文件,推上去:

git push
To https://github.com/你的用户名/你的仓库名.git 4e0b284..658dd8b main -> main

同时原来的同git项目仓库,也提交了,两边仓库项目文件对不上,直接被拒绝:

git push
To https://github.com/你的用户名/你的仓库名.git ! [rejected] main -> main (fetch first)
error: failed to push some refs to 'https://github.com/你的用户名/你的仓库名.git'
hint: Updates were rejected because the remote contains work that you do not
hint: have locally. This is usually caused by another repository pushing to
hint: the same ref. If you want to integrate the remote changes, use
hint: 'git pull' before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

! [rejected] 后面括号里是拒收原因。两种常见原因:

括号里写

含义

出现场景

(fetch first)

对面那条分支上有这边没有的提交

别人先推了,你本地还没抓

(non-fast-forward)

推上去会让对面已有提交掉出线上

你这边历史被改写过(如 reset、amend)

两种都叫非快进:对面那条分支没法原地往前挪一格。共同原因是本地分支的历史不是对面历史的延续, 直接推会让远程丢掉已有提交。Git 宁可拒绝。

解决方法是,先把已经被人更新了的远程仓库内容拿下来,再推:

git fetch #这一步会把远程仓库的新内容下载到本地仓库
From D:/lab/git04/inventory-service 4e0b284..658dd8b main -> origin/main git branch -vv
* main d8c401e [origin/main: ahead 1, behind 1] raise max stock to 120 git status -sb
## main...origin/main [ahead 1, behind 1] git log --oneline main..origin/main
658dd8b add total stock api

git fetch 只做两件事:把对面的新对象下下来,再把那张纸条改成对面此刻的值。 注意它没有碰本地 main,也没有碰工作区——status -sb 只打出分支那一行, 没有任何文件行。

纸条换了值,同一个 cat 前后两次就能看出来:

# 抓取之前
cat .git/refs/remotes/origin/main
4e0b2847009a4e2d38934f2b37f582e96c6c01cf # 抓取之后
cat .git/refs/remotes/origin/main
658dd8b03a65a7257303f9fbef462e6d79e5d5e2

同一个文件,两个不同的提交。方括号里的 [ahead 1, behind 1] 是分叉的标准长相: 本地多一个(ahead)、对面多一个(behind)。 main..origin/main 列出「对面有、这边没有」的那一条。

把对面那条接进来,再推:

git merge origin/main
Merge made by the 'ort' strategy. api.js | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 api.js git push
To https://github.com/你的用户名/你的仓库名.git 658dd8b..23486dc main -> main git branch -vv
* main 23486dc [origin/main] Merge remote-tracking branch 'origin/main'

同一条 git push,第一次 ! [rejected],这一次 658dd8b..23486dc main -> main。中间只多了一步 git merge origin/main: 本地提交成了对面那条的后代,快进成立,拒收理由消失。 方括号也归于 [origin/main],没有数字就是两边一样。

git fetch 加 git merge origin/main 这两步,可以合成一条 git pull。 下一节直接用 pull,顺便看清它停下来的时候停在哪一步。

两个人改了同一行,pull 停在哪一步

先把另一边对齐。它落后一条,快进就够:

git pull
From D:/lab/git04/inventory-service 658dd8b..23486dc main -> origin/main
Updating 658dd8b..23486dc
Fast-forward README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

前面两行是 fetch 干的,后面是合并干的 —— pull 就是这两步连起来跑。 把这行改成 200 提交推上去,然后这边把同一行改成 300,提交,再 pull:

git pull
From D:/lab/git04/inventory-service 23486dc..774a303 main -> origin/main
Auto-merging README.md
CONFLICT (content): Merge conflict in README.md
Automatic merge failed; fix conflicts and then commit the result.

前半段一样,合并那半段卡住了。CONFLICT (content) 是同一个文件的内容撞上, 它不再猜,把两份都写进文件:

{"cat README.md\n" + "# inventory-service\n" + "\n" + "<<<<<<< HEAD\n" + "max stock: 300\n" + "=======\n" + "max stock: 200\n" + ">>>>>>> 774a30344e858fcfd850dfbda93d89ad5ddccbb7\n" + "\n" + "git status -s\n" + "UU README.md"}

方向和第三课一样:HEAD 那一段是这边的 300,下面那段是对面的 200。 只有末行变了 —— 从分支名变成一串哈希,因为 pull 合并的是刚抓下来的 FETCH_HEAD,它没有分支名可写。UU 也是第三课那个:两边都改,还没解决。

改成要的那一行,三段标记全删掉,然后照 add、commit、push 走:

git add README.md
git commit -m "merge: keep 300"
git push
To https://github.com/你的用户名/你的仓库名.git 774a303..bfd2102 main -> main git log --oneline --graph --decorate -4
* bfd2102 (HEAD -> main, origin/main, origin/HEAD) merge: keep 300
|\
| * 774a303 raise max stock to 200
* | c9596f7 raise max stock to 300
|/
* 23486dc Merge remote-tracking branch 'origin/main'

两条线在 bfd2102 接上,那是一个合并提交,第三课的图里见过同样的 |\。半路想整个退回去,还是那条 git merge --abort:这次没合完的东西一并清干净。

想拿手上这份盖掉远程,两个强推命令差在哪

这次提交信息里打错一个字母(clmap)。第二课学过 git commit --amend 改它, 改完再推,拒收理由换了一句:

git commit --amend -m "clamp stock at 200"
[main 7f6ecc1] clamp stock at 200 Date: Sun Nov 15 22:43:49 2026 +0800 1 file changed, 1 insertion(+), 1 deletion(-) git push
To https://github.com/你的用户名/你的仓库名.git ! [rejected] main -> main (non-fast-forward)
error: failed to push some refs to 'https://github.com/你的用户名/你的仓库名.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. If you want to integrate the remote changes,
hint: use 'git pull' before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

括号从 (fetch first) 换成了 (non-fast-forward):对面那条上还停着改之前那个提交, 这边换成了新哈希,两条历史对不上,谁也不是谁的祖先。硬要盖掉,有一个带保险的命令:

git push --force-with-lease
To https://github.com/你的用户名/你的仓库名.git + c092732...7f6ecc1 main -> main (forced update)

行首的 + 和结尾的 (forced update) 说的是同一件事:这不叫前进,这叫换掉。 --force-with-lease 里的 lease 是租约:推之前先比一次 —— 本地那张 origin/main 纸条,和服务器上那一格,是不是同一个提交。

被换掉的那一边,下一次抓取看见的是它:

git fetch
From D:/lab/git04/inventory-service 774a303..7f6ecc1 main -> origin/main git status -sb
## main...origin/main [behind 3] git reset --hard origin/main
HEAD is now at 7f6ecc1 clamp stock at 200

behind 3 说明本地一条都没多,三条全在线上。所以这里丢的东西为零, reset --hard 只是把分支、暂存区、工作区一起指到线上那条 —— 第二课那个会丢改动的命令, 在这种局面下等价于一次快进。

对齐之后加一个函数推上去,接下来这一条是同事的:

git push
To https://github.com/你的用户名/你的仓库名.git 7f6ecc1..2579a8e main -> main

这边再改一次提交信息,这次不抓取就强推:

git commit --amend -m "clamp stock at 200, floor at zero"
[main ba191bc] clamp stock at 200, floor at zero Date: Sun Nov 15 22:43:49 2026 +0800 1 file changed, 1 insertion(+), 1 deletion(-) git push --force-with-lease
To https://github.com/你的用户名/你的仓库名.git ! [rejected] main -> main (stale info)
error: failed to push some refs to 'https://github.com/你的用户名/你的仓库名.git'

(stale info) 是租约过期:纸条上写着 7f6ecc1,服务器上已经换成同事推的那个。 两边的值各问一次,差在哪一目了然:

git rev-parse --short origin/main
7f6ecc1 git ls-remote origin main
2579a8e16576540f3a7955ee5127d365c30f9334	refs/heads/main

左边是本地那张纸条,不碰网络;右边是问服务器得到的此刻值。 --force-with-lease 只比这一件事 —— 它挡的不是覆盖,是「在你不知道的时候被覆盖」。 换成不带租约的 --force,一个检查都不做:

git push --force
To https://github.com/你的用户名/你的仓库名.git + 2579a8e...ba191bc main -> main (forced update) git -C inventory-service.git log --oneline -3
ba191bc clamp stock at 200, floor at zero
bfd2102 merge: keep 300
c9596f7 raise max stock to 300

2579a8e —— 同事刚推的那一条 —— 从远程 main 上消失了。命令成功,没有一句提示。 两个命令只差 -with-lease 这一截,差的是「先问一句」和「不问」。

被抹掉的那份还在同事自己的仓库里,他这边看见的是:

git fetch
From D:/lab/git04/inventory-service + 2579a8e...ba191bc main -> origin/main (forced update) git branch -vv
* main 2579a8e [origin/main: ahead 2, behind 1] count reserved stock

(forced update) 是 fetch 打出来的 —— 强制换历史这件事,抓取的时候瞒不住。 ahead 2 说明那两条提交只在这台机器上。推一次会被拒,接一次再推就回去了:

git push
To https://github.com/你的用户名/你的仓库名.git ! [rejected] main -> main (non-fast-forward)
error: failed to push some refs to 'https://github.com/你的用户名/你的仓库名.git' git pull
Merge made by the 'ort' strategy. git push
To https://github.com/你的用户名/你的仓库名.git ba191bc..6f690bf main -> main

能救回来,是因为同事硬盘上还留着原物。远程被覆盖、本地又没留下的那一份,就没有第二条路了 —— --force 的代价从来不由敲它的人承担。

没有写权限的仓库,改动怎么递进去

上面的 push 都假设你对那个仓库有写权限。别人的仓库你能 clone,推上去会被服务端拒绝。 Fork 解决的就是这一步:用你的账号在服务端复制一份完整仓库,复制品里你有写权限。

acme/inventory-service 原仓库 · 推不进去 └─ Fork ──▶ wangwu/inventory-service 你的复制品 · 有写权限 └─ clone ──▶ 本地这份

照这张图造三份,就是从原仓库到本地这条链:

git clone --bare https://github.com/你的用户名/你的仓库名.git fork-lab/upstream.git
Cloning into bare repository 'fork-lab/upstream.git'...
done. git clone --bare D:/lab/git04/fork-lab/upstream.git fork-lab/fork.git
Cloning into bare repository 'fork-lab/fork.git'...
done. git clone D:/lab/git04/fork-lab/fork.git fork-lab/contrib
Cloning into 'fork-lab/contrib'...
done.

本地这份的 origin 指向自己的复制品。原仓库要另起一个名字加进来,社区习惯叫 upstream。忘了加就去抓,报错原文长这样:

git fetch upstream
fatal: 'upstream' does not appear to be a git repository
fatal: Could not read from remote repository. Please make sure you have the correct access rights
and the repository exists.

加进去之后,一个仓库挂两个远程,两套远程跟踪分支:

git remote add upstream D:/lab/git04/fork-lab/upstream.git
git remote -v
origin	D:/lab/git04/fork-lab/fork.git (fetch)
origin	D:/lab/git04/fork-lab/fork.git (push)
upstream	D:/lab/git04/fork-lab/upstream.git (fetch)
upstream	D:/lab/git04/fork-lab/upstream.git (push) git fetch upstream
From D:/lab/git04/fork-lab/upstream * [new branch] main -> upstream/main git branch -r origin/HEAD -> origin/main origin/main upstream/HEAD -> upstream/main upstream/main

不带名字的 git fetch 和 git push 只碰 origin;原仓库要明写 git fetch upstream。改动照旧在分支上做,新分支第一次推还是要 -u:

git switch -c fix/negative-stock
Switched to a new branch 'fix/negative-stock' git push
fatal: The current branch fix/negative-stock has no upstream branch.
To push the current branch and set the remote as upstream, use git push --set-upstream origin fix/negative-stock To have this happen automatically for branches without a tracking
upstream, see 'push.autoSetupRemote' in 'git help config'. git push -u origin fix/negative-stock
branch 'fix/negative-stock' set up to track 'origin/fix/negative-stock'.
To D:/lab/git04/fork-lab/fork.git * [new branch] fix/negative-stock -> fix/negative-stock git branch -vv
* fix/negative-stock b101d93 [origin/fix/negative-stock] clamp negative stock at zero main 6f690bf [origin/main] Merge branch 'main' of D:/lab/git04/inventory-service

方括号里只有一条,即使挂着两个远程 —— 一条本地分支只跟一条远程分支绑定。 分支已经在自己的复制品上了,接下来那一步在网页上:从 wangwu:fix/negative-stock 往 acme:main 发一个 Pull Request,请维护者把这条分支合进原仓库。

维护者按下「合并」时,对着的就是这两条命令:

git pull D:/lab/git04/fork-lab/fork.git fix/negative-stock
From D:/lab/git04/fork-lab/fork * branch fix/negative-stock -> FETCH_HEAD
Updating 6f690bf..b101d93
Fast-forward stock.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) git push
To D:/lab/git04/fork-lab/upstream.git 6f690bf..b101d93 main -> main

合并之后原仓库的 main 前进了,自己那个复制品还停在原处。两件事要做:

git switch main
Your branch is up to date with 'origin/main'.
Switched to branch 'main' git fetch upstream
From D:/lab/git04/fork-lab/upstream 6f690bf..b101d93 main -> upstream/main git merge upstream/main
Updating 6f690bf..b101d93
Fast-forward stock.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) git push origin main
To D:/lab/git04/fork-lab/fork.git 6f690bf..b101d93 main -> main git branch -vv fix/negative-stock b101d93 [origin/fix/negative-stock] clamp negative stock at zero
* main b101d93 [origin/main] clamp negative stock at zero

先把上游的 main 并下来,再推回自己的复制品。第二条不做,复制品会一直落后, 下次从它开分支就是从一个旧起点开始。

做完了怎么核对

两条命令并排看,就能读懂任何一台机器上的远程状态:

git remote -v
origin	D:/lab/git04/fork-lab/fork.git (fetch)
origin	D:/lab/git04/fork-lab/fork.git (push)
upstream	D:/lab/git04/fork-lab/upstream.git (fetch)
upstream	D:/lab/git04/fork-lab/upstream.git (push) git branch -vv fix/negative-stock b101d93 [origin/fix/negative-stock] clamp negative stock at zero
* main b101d93 [origin/main] clamp negative stock at zero

第一条回答「有哪几份、地址是什么」,第二条回答「每条本地分支跟着哪条、差几个」。 方括号里只有一条远程分支的名字、后面不带数字,就是两边一样。

四条命令各自动到哪一层,这一课跑过的每一步都在表里:

命令

方向

动 origin/main 那张纸条

动本地 main 与磁盘文件

git fetch

向下取

是

否

git pull

向下取并合并

是

是,快进或造合并提交

git push

向上送

是,成功后跟着走

否

git push --force

向上送,不问对面

是

否

团队用哪套流程 —— 主干直推、短分支加 Pull Request、一个版本开一条长期分支 —— 真正的差别只有一处:服务端允不允许直接推 main、 允不允许强推。这一步靠人是记不住的,上面那条 --force 一个检查都没做, 一条命令就让别人刚推的提交从主干上消失。规则得写在服务端,它才是那个会拒绝的东西。

这一课把「共享」拆成四个动作:remote add 交出地址,fetch 只更新纸条, pull 连合并一起做,push 往外送并接受那条快进规则的检查。 远程仓库身上没有魔法 —— 它是另一个仓库,你这边关于它的一切,都记在本地那几个文件和配置里。

还剩一个现象没解释:--amend 只改最后一次提交,远程就整条对不上了。 要是错的是更早的几条提交,或者想把一条分支上的提交整体搬到另一个起点上,哈希对不上会重演一遍, 而且规模更大 —— 那件事怎么做得干净,是下一课的题目。