# 代码管理相关知识点学习文档

## 目录

- [一、Git](#一git)
  - [1. Git 的概念](#1-git-的概念)
  - [2. 三个区域的概念](#2-三个区域的概念)
  - [3. 仓库的概念](#3-仓库的概念)
  - [4. 节点的概念](#4-节点的概念)
  - [5. 分支的概念](#5-分支的概念)
- [二、SourceTree](#二sourcetree)
  - [1. SourceTree 的概念](#1-sourcetree-的概念)
  - [2. 仓库相关操作](#2-仓库相关操作)
  - [3. 节点相关操作](#3-节点相关操作)
  - [4. 分支相关操作](#4-分支相关操作)
  - [5. 其他常用操作](#5-其他常用操作)
  - [6. 综合操作示例](#6-综合操作示例)
- [三、附加内容](#三附加内容)
  - [1. 变基](#1-变基)
  - [2. 创建补丁 2 种及以上](#2-创建补丁-2-种及以上)
  - [3. 应用补丁 2 种及以上](#3-应用补丁-2-种及以上)
- [四、学习总结](#四学习总结)

------

# 一、Git

## 1. Git 的概念

Git 是一个分布式版本控制系统，主要用于管理代码版本、记录文件修改历史、支持多人协作开发。

使用 Git 后，每一次代码提交都会形成一个历史记录，后续可以查看修改内容、回退版本、创建分支、合并代码等。

简单理解：

> Git 就是一个代码版本管理工具，可以记录代码从开始到现在的所有变化过程。

Git 的主要作用：

- 记录代码修改历史；
- 支持版本回退；
- 支持多人协作开发；
- 支持分支开发；
- 方便定位问题和恢复代码。

常见 Git 操作包括：

```bash
# 查看当前仓库状态
git status

# 添加文件到暂存区
git add .

# 提交代码到本地仓库
git commit -m "提交说明"

# 查看提交记录
git log
```

------

## 2. 三个区域的概念

Git 中常说的三个区域分别是：

| 区域     | 英文名称             | 作用                   |
| -------- | -------------------- | ---------------------- |
| 工作区   | Working Directory    | 实际编辑文件的地方     |
| 暂存区   | Staging Area / Index | 临时保存准备提交的修改 |
| 本地仓库 | Local Repository     | 保存正式提交记录的地方 |

### 2.1 工作区

工作区就是电脑中实际看到的项目文件夹，平时写代码、改文件都是在工作区完成的。

例如：

```text
Project/
├── main.c
├── README.md
└── .git/
```

其中 `main.c`、`README.md` 就属于工作区中的文件。

### 2.2 暂存区

暂存区用于临时保存准备提交的文件。

当执行下面命令时，文件会从工作区进入暂存区：

```bash
git add main.c
```

如果要把所有修改加入暂存区，可以使用：

```bash
git add .
```

### 2.3 本地仓库

本地仓库保存的是一次次提交记录。

执行下面命令后，暂存区中的内容会提交到本地仓库：

```bash
git commit -m "完成 main.c 初始化"
```

### 2.4 三个区域之间的关系

```text
工作区  --git add-->  暂存区  --git commit-->  本地仓库
```

简单记法：

- 修改文件：发生在工作区；
- `git add`：把修改放入暂存区；
- `git commit`：把暂存区内容保存到本地仓库。

------

## 3. 仓库的概念

Git 仓库就是被 Git 管理的项目目录。

一个 Git 仓库中通常包含：

- 项目源代码；
- 提交历史；
- 分支信息；
- 标签信息；
- 远程仓库地址配置。

### 3.1 本地仓库

本地仓库是保存在自己电脑上的 Git 仓库。

创建本地仓库命令：

```bash
git init
```

执行后，当前目录下会生成一个 `.git` 隐藏文件夹，该文件夹中保存 Git 版本管理相关信息。

### 3.2 远程仓库

远程仓库是保存在服务器上的仓库，例如 GitLab、GitHub、Gitee 等平台上的仓库。

远程仓库的作用：

- 多人共享代码；
- 备份代码；
- 支持团队协作；
- 便于拉取和推送代码。

关联远程仓库命令：

```bash
git remote add origin 远程仓库地址
```

查看远程仓库：

```bash
git remote -v
```

推送到远程仓库：

```bash
git push origin main
```

从远程仓库拉取代码：

```bash
git pull origin main
```

------

## 4. 节点的概念

Git 中的节点一般指一次提交记录，也就是一个 commit。

每一次执行 `git commit` 后，Git 都会生成一个提交节点。

每个提交节点通常包含：

- 提交编号，也叫 commit hash；
- 提交作者；
- 提交时间；
- 提交说明；
- 本次提交修改的内容；
- 上一个提交节点的信息。

查看提交节点：

```bash
git log --oneline
```

示例：

```text
f3a12bc 修复登录问题
9c8d123 添加用户管理功能
3a4b567 初始化工程
```

其中 `f3a12bc`、`9c8d123`、`3a4b567` 就是不同的提交节点。

简单理解：

> 一个节点就是代码历史中的一个版本快照。

------

## 5. 分支的概念

分支是 Git 中非常重要的概念。

分支可以理解为代码开发的一条独立路线。不同分支之间可以互不影响地进行开发，开发完成后再进行合并。

常见分支：

| 分支名称      | 作用                         |
| ------------- | ---------------------------- |
| main / master | 主分支，保存稳定代码         |
| develop       | 开发分支，保存正在开发的功能 |
| feature_xxx   | 功能分支，用于开发某个新功能 |
| bugfix_xxx    | 修复分支，用于修复问题       |
| release_xxx   | 发布分支，用于版本发布前准备 |

### 5.1 查看分支

```bash
git branch
```

### 5.2 创建分支

```bash
git branch feature_test
```

### 5.3 切换分支

```bash
git checkout feature_test
```

也可以创建并切换：

```bash
git checkout -b feature_test
```

### 5.4 合并分支

假设当前在 `main` 分支，需要合并 `feature_test` 分支：

```bash
git merge feature_test
```

### 5.5 删除分支

```bash
git branch -d feature_test
```

强制删除：

```bash
git branch -D feature_test
```

------

# 二、SourceTree

## 1. SourceTree 的概念

SourceTree 是一个 Git 图形化管理工具，可以通过图形界面完成 Git 的常用操作，例如提交、拉取、推送、创建分支、合并分支、解决冲突等。

简单理解：

> SourceTree 是 Git 的图形界面工具，可以减少命令行操作，让代码管理过程更加直观。

SourceTree 的主要特点：

- 可视化查看提交历史；
- 可视化查看分支关系；
- 支持提交、拉取、推送；
- 支持分支创建、切换、合并、删除；
- 支持冲突解决；
- 支持标签、贮藏、补丁等操作。

------

## 2. 仓库相关操作

## 2.1 创建本地仓库

### SourceTree 操作步骤

1. 打开 SourceTree；
2. 选择“创建”；
3. 选择本地项目路径；
4. 填写仓库名称；
5. 点击创建；
6. 创建完成后，该文件夹会被 Git 管理。

![创建本地仓库](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\创建本地仓库.png)

### 对应 Git 命令

```bash
git init
```

### 说明

创建本地仓库后，项目目录下会生成 `.git` 文件夹，该文件夹用于保存 Git 版本管理信息。

------

## 2.2 打开本地仓库

### SourceTree 操作步骤

1. 打开 SourceTree；
2. 选择“添加“；
3. 选择已经存在的 Git 仓库路径；
4. 点击打开；
5. SourceTree 会加载该仓库的提交记录和分支信息。

![dkbdck](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\打开本地仓库.png)

------

## 2.3 克隆远程仓库

克隆是指从远程服务器下载一份完整仓库到本地。

### SourceTree 操作步骤

1. 打开 SourceTree；
2. 选择“克隆”；
3. 输入远程仓库地址；
4. 选择本地保存路径；
5. 点击克隆；
6. 克隆完成后，本地会生成完整项目。

![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\克隆远程仓库.png)

### 对应 Git 命令

```bash
git clone 远程仓库地址
```

例如：

```bash
git clone https:/http://gitea.xinje.cc/tangxinke/TrainCamp_yuwenhao_Modbus.git
```

------

## 2.4 获取

获取是指从远程仓库获取最新提交信息，但不会自动合并到当前工作分支。

### SourceTree 操作步骤

1. 点击工具栏中的“获取”或“Fetch”；
2. 选择远程仓库；
3. 点击确定；
4. SourceTree 会更新远程分支信息。

![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\获取.png)

### 对应 Git 命令

```bash
git fetch origin
```

### 获取和拉取的区别

| 操作       | 是否下载远程信息 | 是否自动合并到当前分支 |
| ---------- | ---------------- | ---------------------- |
| Fetch 获取 | 是               | 否                     |
| Pull 拉取  | 是               | 是                     |

简单理解：

> 获取只是看看远程有没有新东西，拉取是把远程的新东西拿下来并合并到当前分支。

------

## 2.5 关联远程仓库

关联远程仓库是指给本地仓库添加远程地址。

### SourceTree 操作步骤

1. 打开本地仓库；
2. 进入“仓库设置”；
3. 找到“远程仓库”；
4. 点击“添加”；
5. 填写远程仓库名称，一般为 `origin`；
6. 填写远程仓库地址；
7. 保存设置。

![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\关联远程仓库1.png)

![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\关联远程仓库2.png)

### 对应 Git 命令

```bash
git remote add origin 远程仓库地址
```

查看远程地址：

```bash
git remote -v
```

修改远程地址：

```bash
git remote set-url origin 新的远程仓库地址
```

------

# 3. 节点相关操作

## 3.1 提交

提交是将暂存区中的修改保存为一个新的提交节点。

### SourceTree 操作步骤

1. 修改项目文件；
2. 回到 SourceTree；
3. 在“文件状态”中查看修改文件；
4. 勾选需要提交的文件，使其进入暂存区；
5. 在提交信息框中填写提交说明；
6. 点击“提交”。

![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\提交.png)

### 对应 Git 命令

```bash
git add .
git commit -m "提交说明"
```

### 提交说明建议

提交说明要简洁清楚，例如：

```text
添加用户登录功能
修复串口初始化错误
更新 README 文档
```

不建议写：

```text
修改
改了一点
123
```

------

## 3.2 重置

重置用于将当前分支回到某个历史节点。

Git 中常见重置方式：

| 类型  | 含义     | 影响                           |
| ----- | -------- | ------------------------------ |
| Soft  | 软重置   | 保留工作区和暂存区修改         |
| Mixed | 混合重置 | 保留工作区修改，清空暂存区     |
| Hard  | 硬重置   | 工作区和暂存区都会回到指定版本 |

### SourceTree 操作步骤

1. 在提交历史中选择目标提交节点；

2. 右键该提交；

3. 选择“重置当前分支到此次提交”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\重置当前分支.png)

4. 根据需要选择 软合并、混合合并 或 强行合并；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\重置选型png.png)

5. 确认操作。

### 对应 Git 命令

```bash
# 软重置
git reset --soft 提交ID

# 混合重置
git reset --mixed 提交ID

# 硬重置
git reset --hard 提交ID
```

### 注意

`git reset --hard` 会丢弃工作区未保存的修改，使用前要确认修改是否还需要保留。

------

## 3.3 回滚提交

回滚提交是指生成一个新的提交，用来抵消某一次历史提交的修改。

与重置不同，回滚不会删除历史提交记录，而是新增一个反向提交。

### SourceTree 操作步骤

1. 在提交历史中找到需要回滚的提交；

2. 右键该提交；

3. 选择“回滚提交”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\回滚提交.png)

4. SourceTree 会生成一个新的回滚提交；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\回滚提交2.png)

5. 提交后，原提交的修改效果会被撤销。

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\回滚提交3.png)

### 对应 Git 命令

```bash
git revert 提交ID
```

### 重置和回滚的区别

| 操作        | 是否保留历史 | 是否新增提交 | 常用场景                 |
| ----------- | ------------ | ------------ | ------------------------ |
| reset 重置  | 可能改变历史 | 否           | 本地回退、未推送代码整理 |
| revert 回滚 | 保留历史     | 是           | 已推送代码的安全撤销     |

------

# 4. 分支相关操作

## 4.1 新建分支

### SourceTree 操作步骤

1. 点击工具栏中的“分支”按钮；

2. 输入新分支名称，例如 `feature`；

3. 选择指定的提交；

4. 勾选“检出新分支”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\分支操作.png)

5. 点击创建。

### 对应 Git 命令

```bash
git checkout -b feature/login
```

------

## 4.2 合并分支

合并分支是将一个分支上的修改合并到当前分支。

### SourceTree 操作步骤

1. 先切换到目标分支，例如 `main`；

2. 在左侧分支列表中选择要合并的分支，例如 `feature`；

3. 右键该分支；

4. 选择“合并 feature 至当前分支”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\合并分支.png)

5. 如果没有冲突，合并完成；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\合并分支2.png)

6. 如果有冲突，需要先解决冲突再提交。

### 对应 Git 命令

```bash
git checkout main
git merge feature/login
```

------

## 4.3 删除分支

### SourceTree 操作步骤

1. 确保当前不在要删除的分支上；

2. 在左侧分支列表中找到要删除的分支；

3. 右键该分支；

4. 选择“删除分支”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\删除分支.png)

5. 确认删除。

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\分支删除后.png)

### 对应 Git 命令

```bash
git branch -d feature
```

如果分支未合并，需要强制删除：

```bash
git branch -D feature
```

删除远程分支：

```bash
git push origin --delete feature
```

------

## 4.4 切换分支

### SourceTree 操作步骤

1. 在左侧分支列表中找到目标分支；
2. 双击分支名称，或者右键选择“检出”；
3. 当前工作区会切换到该分支对应的状态。

### 对应 Git 命令

```bash
git checkout 分支名
```

也可以使用：

```bash
git switch 分支名
```

------

## 4.5 制造冲突

冲突通常发生在两个分支修改了同一个文件的同一部分内容，并且 Git 无法自动判断应该保留哪一份。

### 制造冲突示例

1. 在 `main` 分支中创建文件 `test.txt`：

```text
hello main
```
![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\hellomain.png)

1. 提交到 `main` 分支；
2. 创建并切换到 `feature` 分支；
3. 修改 `test.txt`：

```text
hello feature
```
![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\hellofeature.png)

1. 提交 `feature` 分支；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\hellomainupdate.png)

2. 切回 `main` 分支；

3. 修改同一行内容：

```text
hello main update
```

1. 提交 `main` 分支；

2. 将 `feature` 合并到 `main`；

3. 此时就会出现冲突。

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\合并冲突.png)

------

## 4.6 解决冲突

冲突文件中通常会出现类似内容：

```text
<<<<<<< HEAD
hello main update
=======
hello feature
>>>>>>> feature
```

含义：

| 标记                   | 含义                   |
| ---------------------- | ---------------------- |
| `<<<<<<< HEAD`         | 当前分支中的内容开始   |
| `=======`              | 分隔线                 |
| `>>>>>>> feature/test` | 被合并分支中的内容结束 |

### 解决方式

手动修改为最终想保留的内容，例如：

```text
hello main update and feature
```

然后执行：

```bash
git add test.txt
git commit -m "解决 test.txt 合并冲突"
```

### SourceTree 操作步骤

1. 合并分支后，SourceTree 显示存在冲突文件；

2. 打开冲突文件；

3. 手动编辑并删除冲突标记；

4. 保存文件；

5. 在 SourceTree 中将文件标记为已解决；

6. 提交合并结果。

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\合并完成.png)

------

## 4.7 拉取

拉取是将远程仓库的最新代码获取到本地，并自动合并到当前分支。

### SourceTree 操作步骤

1. 点击工具栏中的“拉取”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\拉取.png)

2. 选择远程仓库和远程分支；

3. 点击确定；

4. SourceTree 会执行拉取并合并。

### 对应 Git 命令

```bash
git pull origin 分支名
```

例如：

```bash
git pull origin main
```

------

## 4.8 推送

推送是将本地提交上传到远程仓库。

### SourceTree 操作步骤

1. 本地完成提交；
2. 点击工具栏中的“推送”；
3. 选择要推送的本地分支和远程分支；
4. 点击确定；
5. 推送完成后，远程仓库会更新。

### 对应 Git 命令

```bash
git push origin 分支名
```

例如：

```bash
git push origin main
```

首次推送新分支时，可以使用：

```bash
git push -u origin feature/login
```

------

# 5. 其他常用操作

## 5.1 书写忽略文件

Git 忽略文件通过 `.gitignore` 配置。

`.gitignore` 用于告诉 Git 哪些文件不需要进行版本管理。

常见需要忽略的文件：

- 编译生成文件；
- 临时文件；
- 日志文件；
- IDE 配置文件；
- 密钥、密码等敏感文件。

### 示例 `.gitignore`

```gitignore
# 编译输出目录
build/
Debug/
Release/

# 目标文件
*.o
*.obj
*.exe
*.elf
*.hex
*.bin

# 日志文件
*.log

# 临时文件
*.tmp
*.bak

# 系统文件
.DS_Store
Thumbs.db

# IDE 配置
.vscode/
.idea/
```

### 注意

`.gitignore` 只能忽略还没有被 Git 跟踪的文件。

如果文件已经被 Git 跟踪，需要先停止跟踪。

------

## 5.2 停止跟踪

停止跟踪是指让 Git 不再管理某个已经被跟踪的文件，但文件仍然保留在本地。

![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\停止追踪.png)

### 对应 Git 命令

```bash
git rm --cached 文件名
```

例如：

```bash
git rm --cached config.ini
```

停止跟踪整个文件夹：

```bash
git rm -r --cached build/
```

然后提交：

```bash
git commit -m "停止跟踪 build 目录"
```

### 使用场景

例如某个编译输出目录之前已经提交到了仓库，现在想让 Git 忽略它，可以先执行停止跟踪，再写入 `.gitignore`。

------
## 5.3 创建补丁

补丁文件用于保存代码修改内容，方便在其他分支、仓库或电脑上应用。

创建补丁常见有两种方式：

1. 将**未提交的修改**创建为补丁；
2. 将**已经提交过的 commit** 创建为补丁。

---

### 5.3.1 将未提交的修改创建为补丁

将未提交的修改创建为补丁，是指把当前工作区或暂存区中的代码改动导出为 `.patch` 或 `.diff` 文件。

这种方式适用于代码已经修改，但还没有提交 commit 的情况。

#### 适用场景

- 当前修改还不想提交；
- 需要把未提交的代码修改发给别人；
- 需要把当前修改转移到其他分支；
- 需要临时保存当前工作区中的修改内容。

#### SourceTree 操作步骤

1. 打开 SourceTree，进入对应仓库；

2. 在 **文件状态** 页面确认当前存在未提交修改；

3. 根据需要选择是否暂存文件：

   - 如果要把全部修改都生成补丁，可以直接创建补丁；
   - 如果只想把部分文件生成补丁，可以先将需要的文件加入暂存区。

4. 点击顶部菜单栏中的 **操作**；

5. 选择 **创建补丁**；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\创建一种补丁.png)

6. 在创建补丁窗口中选择 **工作副本的变更**；

7. 勾选需要生成补丁的文件；

8. 选择补丁文件保存位置；

9. 输入补丁文件名，例如：

   ```text
   patch.diff
   ```

![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\创建补丁页.png)

## 5.4 应用补丁 1 种

应用补丁是指将 `.patch` 或 `.diff` 文件中保存的代码修改内容，应用到当前仓库或当前分支中。

应用补丁前，需要先切换到正确的目标分支，并建议保证当前工作区是干净的，避免补丁内容和本地已有修改产生冲突。

---

### 方法：使用 SourceTree 应用补丁

SourceTree 可以直接通过图形界面应用补丁文件，不需要手动输入 Git 命令。

#### 适用场景

- 已经有别人发来的 `.patch` 或 `.diff` 补丁文件；
- 需要把补丁中的修改应用到当前分支；
- 不想手动输入 Git 命令；
- 补丁文件是通过 SourceTree 创建出来的。

#### SourceTree 操作步骤

1. 打开 SourceTree，进入需要应用补丁的仓库；

2. 切换到需要应用补丁的目标分支；

   例如需要把补丁应用到 `develop` 分支，就先切换到 `develop`。

3. 建议先确认当前工作区是干净的，没有未提交修改；

4. 点击顶部菜单栏中的 **操作**；

5. 选择 **应用补丁**；

6. 在弹出的窗口中选择需要应用的补丁文件，例如：

   ```text
   patch.diff
   ```

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\应用补丁.png)

7. 点击 **应用补丁** 或 **确定**；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\应用补丁页.png)

8. 应用成功后，回到 **文件状态** 页面；

9. 查看补丁应用后产生的代码修改；

10. 确认修改内容无误后，勾选需要提交的代码文件；

11. 填写提交说明，例如：

    ```text
    应用补丁 patch.diff
    ```

12. 点击 **提交**，完成补丁应用后的代码提交。

---

### 注意事项

- 应用补丁前，要先确认当前分支正确；
- 应用补丁前，建议保持工作区干净；
- 应用补丁时，不需要将 `.diff` 或 `.patch` 文件加入暂存区；
- `.diff` 或 `.patch` 文件只是补丁文件本身，一般不需要提交到仓库；
- 应用补丁后，真正需要提交的是补丁带来的代码修改；
- 如果补丁应用失败，通常是因为当前代码和补丁生成时的代码差异较大，产生了冲突；
- 如果补丁文件保存在仓库目录中，Git 可能会把它显示为未追踪文件，这种情况下可以不提交它，也可以把补丁文件移动到仓库外部保存。

---

### 简单理解

```text
补丁文件：保存代码修改内容。

应用补丁：把补丁文件中的修改应用到当前分支。

提交代码：应用成功后，提交被补丁修改过的代码文件。
```

补丁文件本身不用提交。

应用补丁后，提交的是被补丁修改过的代码文件。

------
## 5.5 贮藏

贮藏用于临时保存当前未提交的修改，让工作区恢复干净状态。

适合场景：当前正在写代码，但突然需要切换分支处理其他问题。

### SourceTree 操作步骤

1. 当前工作区存在未提交修改；

2. 点击“仓库”；

3. 点击“贮藏变更”；

4. 输入贮藏说明；

5. 确认后，当前修改会被临时保存；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\贮藏.png)

6. 工作区恢复到干净状态。

### 对应 Git 命令

```bash
git stash save "临时保存当前修改"
```

查看贮藏列表：

```bash
git stash list
```

恢复最近一次贮藏：

```bash
git stash pop
```

只应用但不删除贮藏：

```bash
git stash apply
```

说明：

`git stash apply` 表示将贮藏中的修改重新应用到当前工作区，但不会删除该条贮藏记录。

也就是说，执行后：

- 之前临时保存的修改会恢复到工作区；
- 贮藏列表中仍然保留这条记录；
- 如果后续还需要再次恢复，可以继续使用该贮藏。

在 SourceTree 中，对应操作为：

右键左侧“贮藏”列表中的某条贮藏记录，选择“应用贮藏”。

“应用贮藏”和“弹出贮藏”的区别如下：

| 操作 | 作用 |
| ---- | ---- |
| 应用贮藏 | 恢复修改，但保留贮藏记录 |
| 弹出贮藏 | 恢复修改，同时删除贮藏记录 |

因此，在不确定是否还需要该贮藏记录时，建议优先使用“应用贮藏”。

删除某个贮藏：

```bash
git stash drop stash@{0}
```
------

## 5.6 丢弃

丢弃用于放弃当前工作区中未提交的修改，使文件恢复到上一次提交时的状态。

简单理解：  
如果某个文件修改错了，并且不想保留这次修改，就可以使用“丢弃”操作。

注意：丢弃操作一般用于**未暂存文件**。如果文件已经暂存，需要先取消暂存，再进行丢弃。

### 适合场景

- 文件修改错误，不想保留当前改动；
- 当前修改只是临时测试代码；
- 想让文件恢复到上一次提交时的状态；
- 不需要把当前修改提交到仓库。

### SourceTree 操作步骤

1. 在文件状态区域选中需要放弃修改的文件；

2. 右键该文件；

3. 点击“恢复文件改动”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\丢弃操作.png)

4. 在弹出的确认窗口中确认；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\丢弃.png)

5. 文件会恢复到上一次提交时的状态。

注意：“恢复文件改动”相当于丢弃当前未提交修改，操作后当前修改会被删除。

### 对应 Git 命令

丢弃某个未暂存文件的修改：

```bash
git restore 文件名
```

------

## 5.7 移除

移除是指从 Git 仓库中删除文件。

### SourceTree 操作步骤

1. 在文件状态区域选中需要移除的文件；

2. 右键该文件；

3. 点击“移除”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\移除.png)

4. 在弹出的确认窗口中确认；

5. 文件会从本地工作区删除，并在 SourceTree 中显示为删除状态；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\删除状态.png)

6. 点击暂存所有；

7. 点击“提交”，Git 会记录该文件被删除；

8. 如果需要同步到远程仓库，再点击“推送”。

------

## 5.8 创建标签

标签用于给某个提交节点打上版本标记，常用于版本发布。

例如：

```text
v1.0.0
v1.1.0
v2.0.0
```

### SourceTree 操作步骤

1. 在提交历史中选择一个提交节点；

2. 右键该提交；

3. 选择“标签”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\标签.png)

4. 输入标签名称，例如 `v1.0.0`；

5. 确认创建。

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\标签2.png)

### 对应 Git 命令

```bash
git tag v1.0.0
```

给指定提交创建标签：

```bash
git tag v1.0.0 提交ID
```

推送标签到远程：

```bash
git push origin v1.0.0
```

推送所有标签：

```bash
git push origin --tags
```

------

## 5.9 删除标签

### 删除本地标签

```bash
git tag -d v1.0.0
```

### 删除远程标签

```bash
git push origin --delete v1.0.0
```

### SourceTree 操作步骤

1. 在左侧标签列表中找到目标标签；
2. 右键标签；
3. 选择删除；
4. 如果需要删除远程标签，需要推送删除操作。

------

# 6. 综合操作示例

## 6.1 一系列操作后最终状态

下面通过一个完整流程说明 Git 和 SourceTree 的基本使用过程。

### 操作流程

1. 创建本地仓库 `GitStudy`；
2. 新建文件 `README.md`；
3. 提交初始版本；
4. 创建分支 `feature/add-doc`；
5. 在分支中修改 `README.md`；
6. 提交修改；
7. 切换回 `main` 分支；
8. 合并 `feature/add-doc`；
9. 创建标签 `v1.0.0`；
10. 推送 `main` 分支和标签到远程仓库。

### 对应 Git 命令

```bash
mkdir GitStudy
cd GitStudy

git init

echo "# GitStudy" > README.md

git add README.md
git commit -m "初始化 README 文档"

git checkout -b feature/add-doc

echo "学习 Git 和 SourceTree" >> README.md

git add README.md
git commit -m "补充 Git 学习说明"

git checkout main
git merge feature/add-doc

git tag v1.0.0

git remote add origin 远程仓库地址
git push -u origin main
git push origin v1.0.0
```

### 最终状态说明

| 内容                 | 最终状态                 |
| -------------------- | ------------------------ |
| 当前分支             | main                     |
| README.md            | 包含初始化内容和新增说明 |
| feature/add-doc 分支 | 已合并到 main            |
| 标签                 | 已创建 v1.0.0            |
| 远程仓库             | 已推送 main 分支和标签   |
| 工作区               | 干净，无未提交修改       |

查看最终状态：

```bash
git status
```

正常情况下会显示类似：

```text
nothing to commit, working tree clean
```

------

# 三、附加内容

## 1. 变基

变基英文是 Rebase，是 Git 中整理提交历史的一种方式。

变基可以把当前分支的提交移动到另一个分支的最新提交之后，使提交历史看起来更加线性。

### 1.1 变基和合并的区别

| 操作        | 特点                     | 提交历史               |
| ----------- | ------------------------ | ---------------------- |
| merge 合并  | 保留真实分支合并记录     | 可能出现分叉和合并节点 |
| rebase 变基 | 将提交移动到目标分支后面 | 历史更加线性           |

### 1.2 变基示意

变基前：

```text
A---B---C  main
     \
      D---E  feature
```

在 `feature` 分支执行：

```bash
git rebase main
```

变基后：

```text
A---B---C---D'---E'  feature
```

说明：

`D` 和 `E` 会被重新应用到 `C` 后面，并形成新的提交 `D'` 和 `E'`。

### 1.3 SourceTree 中变基操作

1. 切换到需要变基的分支，例如 `bianji`；

2. 在左侧分支中选择目标分支，例如 `main`；

3. 右键目标分支；

4. 选择“变基当前变更到 main”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\bianji2.png)

5. 如果有冲突，需要解决冲突后继续变基。

   变基前![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\bianjiqian.png)
   变基后![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\bianjihou.png)

### 1.4 对应 Git 命令

```bash
git checkout feature
git rebase main
```

如果出现冲突，解决冲突后执行：

```bash
git add 冲突文件
git rebase --continue
```

放弃变基：

```bash
git rebase --abort
```

### 1.5 注意事项

已经推送到远程并被别人使用的公共分支，不建议随意变基。

原因是变基会改变提交历史，可能影响其他人的开发进度。

------

## 2. 创建补丁 2 种及以上

补丁文件用于保存代码修改内容，方便在其他分支、仓库或电脑上重新应用这些修改。

在 SourceTree 中，创建补丁常见可以分为以下几种情况：

1. 将**未提交的修改**创建为补丁；
2. 将**已经提交过的单个 commit** 创建为补丁；
3. 将**多个 commit 或一段提交范围**创建为补丁；
4. 将**部分文件的修改**创建为补丁。

### 2.1 将未提交的修改创建为补丁

将未提交的修改创建为补丁，是指把当前工作区或暂存区中的代码改动导出为 `.patch` 或 `.diff` 文件。

这种方式适用于代码已经修改，但还没有提交 commit 的情况。

#### 适用场景

- 当前修改还不想提交；
- 需要把未提交的代码修改发给别人；
- 需要把当前修改转移到其他分支；
- 需要临时保存当前工作区中的修改内容。

#### SourceTree 操作步骤

1. 参考二、5.3


#### 注意事项

- 创建补丁不一定需要先暂存文件；
- 如果是修改已有文件，一般可以直接创建补丁；
- 如果是新建文件，建议先将新文件加入暂存区；
- 如果新建文件为空，补丁中可能看不到该文件，因为空文件没有实际代码差异；
- 补丁文件一般不需要加入 Git 追踪，也不需要提交到仓库中。

### 2.2 将已经提交过的单个 commit 创建为补丁

将单个 commit 创建为补丁，是指把某一次已经提交过的代码修改导出为补丁文件。

这种方式适用于代码已经 commit，但不方便直接 push，或者需要把某次提交发送给别人使用的情况。

#### 适用场景

- 代码已经提交，但不方便直接推送到远程仓库；
- 需要把某一次提交发给别人；
- 需要把某一次提交应用到其他分支；
- 需要保留该次提交对应的修改内容。

#### SourceTree 操作步骤

1. 打开 SourceTree，进入对应仓库；

2. 找到需要创建补丁的 commit；

3. 选中该 commit；

4. 点击顶部菜单栏中的 **操作**；

5. 选择 **创建补丁**；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\操作创建补丁.png)

6. 切换到 **日志 / 历史** 页面；

7. 在创建补丁窗口中切换到 **日志 / 历史**；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\创建补丁日志历史.png)

8. 确认选中的 commit 是否正确；

9. 在 **补丁文件** 一栏中选择补丁保存位置和文件名，例如：

   ```text
   fixbug.diff
   ```

10. 点击 **创建补丁**；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\选中创建补丁.png)

11. 创建完成后，会生成一个对应的补丁文件。

#### 说明

这种方式创建的补丁来源于已经提交过的 commit。

相比未提交修改创建的补丁，这种补丁更适合用于传递某一次完整的提交修改。

### 2.3 将多个 commit 或一段提交范围创建为补丁

将多个 commit 创建为补丁，是指把连续或多个已经提交过的提交记录一起导出为补丁文件。

这种方式适用于需要把一组相关修改整体转移到其他分支或仓库的情况。

#### 适用场景

- 一个功能由多个 commit 组成；
- 一个问题修复涉及多次提交；
- 需要把某一段提交记录整体发给别人；
- 需要把某个分支上的一组提交迁移到另一个分支。

#### SourceTree 操作步骤

1. 打开 SourceTree，进入对应仓库；

2. 点击顶部菜单栏中的 **操作**；

3. 选择 **创建补丁**；

4. 创建补丁窗口中切换到 **日志 / 历史** 页面；

5. 找到需要导出的多个 commit；

   可以根据实际情况选择单个 commit、多个 commit，或者一段连续的提交范围。

6. 按住 ”ctrl“ 选中需要创建补丁的提交记录；

7. 确认需要导出的 commit 范围是否正确；

8. 在 **补丁文件** 一栏中选择补丁保存位置和文件名，例如：

   ```text
   feature_update.diff
   ```

9. 点击 **创建补丁**；

10. 创建完成后，会生成包含这些提交修改内容的补丁文件。

#### 注意事项

- 多个 commit 创建补丁时，要确认提交顺序和提交范围是否正确；
- 如果多个提交之间有关联，应用补丁时也需要保证目标分支的代码基础一致；
- 如果目标分支代码和补丁生成时差异较大，应用补丁时可能会失败或产生冲突。

### 2.4 将部分文件的修改创建为补丁

将部分文件创建为补丁，是指当前修改了多个文件，但只想把其中几个文件的修改导出为补丁。

这种方式本质上仍然属于“未提交修改创建补丁”，只是只选择其中一部分文件。

#### 适用场景

- 当前修改了很多文件，但只想导出其中几个文件；
- 有些修改还不想给别人；
- 想把一个大修改拆成多个小补丁；
- 想单独保存某几个文件的修改内容。

#### SourceTree 操作步骤

1. 打开 SourceTree，进入对应仓库；

2. 进入 **文件状态** 页面；

3. 查看当前所有修改文件；

4. 如果只想导出部分文件，可以先将需要的文件加入暂存区；

5. 点击顶部菜单栏中的 **操作**；

6. 选择 **创建补丁**；

7. 在创建补丁窗口中选择 **工作副本的变更**；

8. 只勾选需要生成补丁的文件；

9. 在 **补丁文件** 一栏中选择补丁保存位置和文件名，例如：

   ```text
   part_update.patch
   ```

10. 点击 **创建补丁**；

11. 创建完成后，补丁文件中只会包含所选文件的修改内容。

### 2.5 补丁文件保存位置

创建补丁时，补丁文件保存在哪里，取决于 **补丁文件** 一栏中填写的路径。

例如：

```text
F:\信捷电气\训练营\代码\StageTwo\patch.diff
```

表示补丁文件保存在：

```text
F:\信捷电气\训练营\代码\StageTwo\
```

文件名为：

```text
patch.diff
```

如果补丁文件保存在 Git 仓库目录中，SourceTree 可能会将它显示为未追踪文件。

一般情况下，补丁文件不需要提交到仓库中，可以将补丁文件保存到仓库外部，避免误提交。

### 2.6 几种创建补丁方式的区别

| 创建方式             | 来源           | 是否已经提交 | 适用情况                                |
| -------------------- | -------------- | ------------ | --------------------------------------- |
| 未提交修改创建补丁   | 工作区或暂存区 | 未提交       | 当前修改还没有 commit，需要导出修改内容 |
| 单个 commit 创建补丁 | 某一次提交记录 | 已提交       | 需要导出某一次提交                      |
| 多个 commit 创建补丁 | 多次提交记录   | 已提交       | 需要导出一组相关提交                    |
| 部分文件创建补丁     | 部分文件修改   | 不一定       | 只想导出某几个文件的修改                |

### 2.7 简单理解

```text
代码还没有提交：
从“工作副本的变更”创建补丁。

代码已经提交：
从“日志 / 历史”中的 commit 创建补丁。

只想导出部分文件：
在创建补丁窗口中只勾选需要的文件。

补丁文件本身：
一般不用提交到 Git 仓库。
```




------

## 3. 应用补丁 2 种及以上

## 3.1 方法一：使用 `git apply` 应用补丁

适用于 `git diff` 生成的普通补丁。

检查补丁是否能应用：

```bash
git apply --check update.patch
```

应用补丁：

```bash
git apply update.patch
```

应用后需要手动提交：

```bash
git add .
git commit -m "应用 update.patch 补丁"
```

特点：

- 只应用代码差异；
- 不会自动生成提交；
- 不保留原提交作者和提交说明。

------

## 3.2 方法二：使用 `git am` 应用补丁

适用于 `git format-patch` 生成的补丁。

```bash
git am 0001-xxx.patch
```

如果有多个补丁文件：

```bash
git am *.patch
```

特点：

- 会自动生成提交；
- 保留原提交作者、时间和提交说明；
- 适合正式补丁合入。

如果应用失败，可以放弃：

```bash
git am --abort
```

解决冲突后继续：

```bash
git add 冲突文件
git am --continue
```

------

## 3.3 方法三：使用 SourceTree 应用补丁

一般操作步骤：

1. 打开目标仓库；

2. 找到“操作”；

3. 选择“应用补丁”；

   ![](F:\信捷电气\训练营\第一周\学习文档\yuwenhao\SourceTree\pictures\操作.png)

4. 选择补丁文件；

5. 如果没有冲突，补丁会被应用到当前工作区；

6. 检查修改内容；

7. 提交修改。

注意：

- 普通 diff 补丁通常应用后需要手动提交；
- format-patch 补丁如果通过命令行 `git am` 应用，会自动形成提交。

------

# 四、学习总结

通过本次学习，掌握了 Git 和 SourceTree 的基础知识以及常用操作。

## 1. Git 核心知识总结

| 知识点   | 说明                         |
| -------- | ---------------------------- |
| Git      | 分布式版本控制系统           |
| 工作区   | 实际修改文件的地方           |
| 暂存区   | 临时保存准备提交的修改       |
| 本地仓库 | 保存提交历史的地方           |
| 远程仓库 | 服务器上的共享仓库           |
| 节点     | 一次提交记录                 |
| 分支     | 独立开发路线                 |
| 合并     | 把一个分支内容合入另一个分支 |
| 变基     | 整理提交历史，使历史更线性   |
| 标签     | 给某个提交打版本标记         |

## 2. SourceTree 核心操作总结

| 操作         | 作用                         |
| ------------ | ---------------------------- |
| 创建本地仓库 | 初始化一个 Git 仓库          |
| 打开本地仓库 | 使用 SourceTree 管理已有仓库 |
| 克隆远程仓库 | 从服务器下载代码             |
| 获取         | 获取远程更新但不自动合并     |
| 拉取         | 获取远程更新并合并           |
| 推送         | 上传本地提交到远程仓库       |
| 提交         | 保存一次代码版本             |
| 重置         | 回到某个历史节点             |
| 回滚提交     | 用新提交撤销旧提交           |
| 新建分支     | 创建独立开发路线             |
| 合并分支     | 合并不同分支代码             |
| 解决冲突     | 处理不同分支中重复修改的问题 |
| 贮藏         | 临时保存未提交修改           |
| 丢弃         | 放弃未提交修改               |
| 标签         | 标记版本节点                 |
| 补丁         | 导出或应用代码修改           |

## 3. 常用命令汇总

```bash
# 初始化仓库
git init

# 克隆仓库
git clone 远程仓库地址

# 查看状态
git status

# 添加到暂存区
git add .

# 提交
git commit -m "提交说明"

# 查看日志
git log --oneline

# 查看分支
git branch

# 创建并切换分支
git checkout -b 分支名

# 切换分支
git checkout 分支名

# 合并分支
git merge 分支名

# 拉取
git pull origin 分支名

# 推送
git push origin 分支名

# 创建标签
git tag 标签名

# 贮藏
git stash

# 恢复贮藏
git stash pop

# 创建普通补丁
git diff > update.patch

# 应用普通补丁
git apply update.patch

# 创建提交补丁
git format-patch -1 HEAD

# 应用提交补丁
git am 0001-xxx.patch
```

## 4. 个人学习体会

Git 的核心是理解工作区、暂存区、本地仓库和远程仓库之间的关系。SourceTree 作为图形化工具，可以帮助我们更加直观地理解分支、提交节点和代码合并过程。

在实际开发中，应养成以下习惯：

- 修改代码前先拉取最新代码；
- 每次提交只完成一个明确功能；
- 提交说明要清楚；
- 不要随意提交编译生成文件；
- 合并代码前先确认分支状态；
- 遇到冲突时先理解差异，再决定保留内容；
- 对公共分支谨慎使用重置和变基。

------

