1. 先分清楚：本地仓库、自己的远程仓库、原始远程仓库#

假设有一个开源项目：

1
原始仓库：
2
github.com/original/project

你点击 GitHub 上的 Fork 之后，会得到一个你自己账号下的仓库：

1
你的 Fork 仓库：
2
github.com/yourname/project

然后你在本地执行：

1
git clone https://github.com/yourname/project.git

这时你电脑里会有一份本地仓库。 所以一个标准的 fork 工作流里，通常有三份仓库：

1
原始仓库 upstream：github.com/original/project
2
你的远程仓库 origin：github.com/yourname/project
3
你的本地仓库 local：你电脑上的 project 文件夹

其中：

• upstream 通常表示原始仓库，也就是你 fork 的来源。
• origin 通常表示你自己的远程仓库，也就是你 clone 下来的那个地址。
• local 表示你电脑上的本地仓库。

2. Fork 之后，原仓库更新会自动同步吗？#

不会完全自动同步。 Fork 之后，你的 GitHub 仓库是原仓库在某一时刻的副本。 比如你在 6 月 1 日 fork 了项目：

1
original/project  6月1日版本
2
yourname/project  6月1日版本

后来原始仓库在 6 月 10 日更新了：

1
original/project  6月10日版本
2
yourname/project  仍然是6月1日版本

你的 fork 仓库不会自动变成最新状态。 GitHub 页面上有时候会显示：

1
This branch is 5 commits behind original:main

意思是你的 fork 落后于原仓库。 你可以在 GitHub 网页上点 Sync fork 来同步，也可以在本地用命令同步。

3. Fork 的更新是同步到 GitHub 里，还是同步到本地里？#

这要看你怎么操作。 如果你在 GitHub 网页上点 Sync fork，同步的是：

1
原始远程仓库 upstream → 你的远程仓库 origin

也就是说，GitHub 上你的 fork 更新了，但你本地电脑里的代码不会自动更新。

你还需要在本地执行：

1
git pull

把你远程仓库的新内容拉到本地。

如果你在本地用命令同步，一般流程是：

1
git remote add upstream https://github.com/original/project.git
2
git fetch upstream
3
git checkout main
4
git merge upstream/main  表示远程仓库 upstream 里的 main 分支
5
git push origin main

这套命令的含义是：

1
1. 添加原始仓库地址，命名为 upstream
2
2. 从 upstream 获取最新内容
3
3. 切换到本地 main 分支
4
4. 把 upstream/main 合并到本地 main
5
5. 把更新后的本地 main 推送到自己的 GitHub fork 仓库

这样本地和你的 GitHub fork 都会更新。

4. Clone 是什么？#

clone 是把远程仓库下载到本地。 比如：

1
git clone https://github.com/yourname/project.git

执行之后，本地会出现一个 project 文件夹。 这个文件夹不仅包含项目文件，还包含一个隐藏目录：

1
.git/

.git 里面保存了 Git 的版本信息、分支信息、提交历史、远程仓库地址等。 可以用下面的命令查看远程仓库地址：

1
git remote -v

一般你会看到：

1
origin  https://github.com/yourname/project.git (fetch)
2
origin  https://github.com/yourname/project.git (push)

这里的 origin 就是你自己的 fork 仓库。

5. Fork 和 Clone 的区别#

很多人会把 fork 和 clone 搞混。 它们的区别是：

1
fork：发生在 GitHub 上，是复制一个远程仓库到你的 GitHub 账号下。
2
clone：发生在本地电脑上，是把某个远程仓库下载到本地。

举个例子：

1
别人仓库：original/project
2
点击 Fork
3
你的仓库：yourname/project
4
执行 git clone
5
本地仓库：电脑里的 project 文件夹

所以 fork 和 clone 通常是配合使用的：

1
先 fork，再 clone。

6. Branch 分支是什么？#

分支可以理解成一条独立的开发线。

假设 main 分支是项目的主线：

1
main

你想开发一个新功能，不应该直接在 main 上乱改，而是新建一个分支：

1
git checkout -b feature-login

这表示：

1
从当前分支切出一个新分支，名字叫 feature-login，并切换过去。

现在你在 feature-login 分支上改代码，不会影响 main 分支。

7. 分支 A 和分支 B 的文件会互相影响吗？#

假设有两个分支：

1
分支 A：有 x、y、z、n 文件
2
分支 B：有 o、p、q、n 文件

这里 n 是公共文件。 如果你在分支 A 修改 n 文件：

1
A 分支的 n 被修改

此时不会影响 B 分支里的 n 文件。 因为每个分支都有自己的一套文件状态。 也就是说：

1
只要你还没有 merge，A 分支和 B 分支之间互不影响。

但是如果你后来把 A 合并到 B，或者把 B 合并到 A，就可能发生影响。

8. 如果 A 和 B 都修改了公共文件 n，会怎样？#

情况分两种。

1
A 分支修改了 n 文件第 10 行
2
B 分支修改了 n 文件第 50 行

1
A 分支修改了 n 文件第 10 行
2
B 分支也修改了 n 文件第 10 行

1
<<<<<<< HEAD
2
这是当前分支的内容
3
=======
4
这是要合并进来的分支的内容
5
>>>>>>> branch-name

1
git add n
2
git commit

9. Merge 到底是合并到哪个分支？#

这是一个非常重要的问题。 Git 的 merge 规则是：

1
当前你在哪个分支，merge 就是把别的分支合并到当前分支。

比如现在有两个分支：

1
main
2
feature-login

如果你执行：

1
git checkout main
2
git merge feature-login

意思是：

1
把 feature-login 合并到 main。

如果你执行：

1
git checkout feature-login
2
git merge main

意思是：

1
把 main 合并到 feature-login。

所以 merge 的方向不是看命令里的分支是谁，而是看你当前所在的分支是谁。 记住一句话：

1
git merge xxx = 把 xxx 合并到我当前所在的分支。

10. 要不要单独搞一个分支作为主分支？#

通常不需要额外搞一个奇怪的“合并分支”。 一般项目结构是：

1
main：稳定主分支
2
dev：开发集成分支，可选
3
feature-xxx：具体功能分支
4
fix-xxx：修复 bug 分支

如果是个人小项目，通常这样就够了：

1
main
2
feature-xxx

开发流程：

1
git checkout main
2
git pull
3
git checkout -b feature-login
4
# 修改代码
5
git add .
6
git commit -m "add login feature"
7
git push origin feature-login

然后在 GitHub 上发 PR，把：

1
feature-login → main

合并进去。 如果是多人协作，可能会有：

1
main：正式稳定版本
2
dev：日常开发整合分支
3
feature-a：成员 A 的功能
4
feature-b：成员 B 的功能

流程可能是：

1
feature-a → dev
2
feature-b → dev
3
dev 测试稳定后 → main

但是对于大多数个人项目或者课程项目，不需要搞得太复杂。

11. Fork 之后，自己的远程仓库是不是 main 分支？#

一般是。 当你 fork 一个仓库时，你会复制原仓库的默认分支。 如果原仓库默认分支叫：

1
main

你的 fork 仓库默认分支通常也叫：

1
main

如果原仓库默认分支叫：

1
master

你的 fork 仓库默认分支通常也叫：

1
master

所以 fork 之后，你自己的远程仓库不一定必须是 main，要看原仓库默认分支叫什么。 可以用下面命令查看本地分支：

1
git branch

查看本地和远程所有分支：

1
git branch -a

12. 自己要不要搞一个 self 分支？#

一般不建议叫 self 分支。 更推荐按照任务命名，比如：

1
feature-login
2
feature-user-page
3
fix-navbar-bug
4
docs-update-readme
5
experiment-model-v2

如果你是 fork 了别人的仓库，想长期保留自己的修改版本，可以有一个自己的长期分支，比如：

1
my-main
2
custom
3
personal

但普通协作里，更推荐：

1
main：和原仓库主分支保持同步
2
feature-xxx：自己真正开发的内容

这样更清楚。 推荐结构：

1
upstream/main：原始仓库主分支
2
origin/main：你的 fork 仓库主分支，尽量和 upstream/main 保持同步
3
origin/feature-xxx：你自己的开发分支
4
local feature-xxx：你本地的开发分支

不要长期直接在自己的 main 上乱改，否则以后同步 upstream/main 的时候容易冲突。

简单来说就是自己新建一个自己的开发分支，然后你就在自己的开发分支里改东西即可，然后源仓库有修改的话直接合并到main分支，然后再把main分支里的东西合并到你自己的开发分支

13. Fork 项目的推荐工作流#

假设你 fork 了一个开源项目。

1
github.com/yourname/project

1
git clone https://github.com/yourname/project.git
2
cd project

1
git remote add upstream https://github.com/original/project.git

1
git remote -v

1
origin    https://github.com/yourname/project.git
2
upstream  https://github.com/original/project.git

1
git checkout main
2
git fetch upstream
3
git merge upstream/main
4
git push origin main

1
git checkout -b feature-login

1
git status
2
git add .
3
git commit -m "add login feature"

1
git push origin feature-login

1
yourname/project:feature-login
2
→ original/project:main

1
请求把你 fork 仓库里的 feature-login 分支合并到原始仓库的 main 分支。

14. 合并 Pull Request 是合并到哪里？#

PR 合并到哪里，取决于 PR 页面里选择的目标分支。

比如：

1
base repository: original/project
2
base branch: main
3

4
compare repository: yourname/project
5
compare branch: feature-login

这表示：

1
把 yourname/project 的 feature-login 合并到 original/project 的 main。

如果是你自己的项目，也可以是：

1
base repository: yourname/project
2
base branch: main
3

4
compare branch: feature-login

这表示：

1
把自己的 feature-login 合并到自己的 main。

所以 PR 的方向一定要看清楚：

1
compare → base

也就是：

1
你的修改分支 → 目标分支

15. 常见命令总结#

1
git status

1
git branch

1
git branch -a

1
git checkout -b feature-name

1
git switch -c feature-name

1
git checkout main

1
git switch main

1
git remote -v

1
git remote add upstream https://github.com/original/project.git

1
git fetch origin
2
git fetch upstream

1
git pull origin main

1
git fetch origin
2
git merge origin/main

1
git checkout main
2
git merge feature-name

1
把 feature-name 合并到 main。

1
git push origin feature-name

1
git branch -d feature-name

1
git branch -D feature-name

1
git push origin --delete feature-name

16. fetch、pull、merge 的区别#

1
git fetch upstream

1
把远程仓库的新提交拿到本地，但不修改当前代码。

1
git merge upstream/main

1
把 upstream/main 合并到当前分支。

1
git pull upstream main

1
git fetch upstream
2
git merge upstream/main

1
git fetch
2
git merge

17. rebase 是什么？和 merge 有什么区别？#

merge 是把两个分支合并起来，会保留分叉历史。

例如：

1
main:    A---B---C
2
feature:      \---D---E

执行 merge 后可能变成：

1
main:    A---B---C-------M
2
              \         /
3
feature:       D---E----

M 是一个 merge commit。

rebase 是把你的提交“搬到”最新主分支后面。

1
main:    A---B---C
2
feature:      \---D---E

执行 rebase 后变成：

1
main:    A---B---C
2
feature:          \---D'---E'

rebase 的历史更直，但对新手来说更容易出问题。

简单建议：

1
个人功能分支可以 rebase。
2
公共分支不要随便 rebase。
3
新手先用 merge。

18. 一个很常见的场景：原仓库更新了，我的分支怎么办？#

你正在 feature-login 分支开发，但原仓库 main 更新了。

推荐流程：

1
git checkout main
2
git fetch upstream
3
git merge upstream/main
4
git push origin main

这一步先更新自己的 main。

然后切回自己的功能分支：

1
git checkout feature-login
2
git merge main

意思是：

1
把最新 main 合并到自己的 feature-login。

这样你的功能分支就基于最新代码继续开发。

也可以用 rebase：

1
git checkout feature-login
2
git rebase main

但新手可以先用 merge。

19. 最容易搞混的几个问题#

1
git checkout main
2
git merge feature-a

1
main 保持和原仓库同步
2
feature-xxx 用来写自己的修改

20. 推荐的安全习惯#

1
git status
2
git branch

1
git checkout main
2
git pull
3
git checkout -b feature-xxx

1
feature-login
2
feature-homepage
3
fix-database-config
4
docs-readme

1
git commit -m "update"

1
git commit -m "fix navbar layout on mobile"
2
git commit -m "add user login form"
3
git commit -m "update README installation steps"

1
git checkout main
2
git fetch upstream
3
git merge upstream/main
4
git push origin main
5

6
git checkout feature-xxx
7
git merge main
8
git push origin feature-xxx

21. 一张图理解完整流程#

1
原始仓库 upstream
2
github.com/original/project
3
        │
4
        │ Fork
5
        ▼
6
你的远程仓库 origin
7
github.com/yourname/project
8
        │
9
        │ Clone
10
        ▼
11
你的本地仓库 local
12
电脑里的 project 文件夹

开发时：

1
upstream/main
2
     │
3
     │ 同步
4
     ▼
5
origin/main
6
     │
7
     │ clone / pull
8
     ▼
9
local/main
10
     │
11
     │ checkout -b
12
     ▼
13
local/feature-xxx
14
     │
15
     │ push
16
     ▼
17
origin/feature-xxx
18
     │
19
     │ Pull Request
20
     ▼
21
upstream/main

22. 最推荐的新手工作流#

如果你 fork 了别人的项目，推荐这样做：

1
# 1. 克隆自己的 fork
2
git clone https://github.com/yourname/project.git
3
cd project
4

5
# 2. 添加原始仓库
6
git remote add upstream https://github.com/original/project.git
7

8
# 3. 更新自己的 main
9
git checkout main
10
git fetch upstream
11
git merge upstream/main
12
git push origin main
13

14
# 4. 新建功能分支
15
git checkout -b feature-my-change
16

17
# 5. 修改代码后提交
18
git add .
19
git commit -m "add my change"
20

21
# 6. 推送到自己的 fork
22
git push origin feature-my-change

然后在 GitHub 上发 PR：

1
yourname/project:feature-my-change
2
→ original/project:main

如果只是自己的项目，不涉及 fork，可以简化成：

1
git checkout main
2
git pull
3
git checkout -b feature-my-change
4
git add .
5
git commit -m "add my change"
6
git push origin feature-my-change

然后在 GitHub 上把 feature-my-change 合并到 main。

23. 最核心的一句话总结#

Fork 是复制别人的远程仓库，clone 是下载仓库到本地，branch 是在同一个仓库里开新的开发线，merge 是把一个分支合并到当前分支，PR 是在 GitHub 上请求把一个分支合并到另一个分支。

真正推荐的方式是：

1
main 保持干净和同步；
2
每个功能单独开分支；
3
开发完成后通过 PR 合并；
4
合并前先同步最新 main；
5
出现冲突就手动解决。