【Git】Git 学习笔记——本地仓库管理

Git 使用方法

前言：

无笔墨不读书，边实践边积累，边积累边巩固。

一、Git 安装后指定名称和邮箱

git config --global user.name "Your Name"
git config --global user.email "Your Email"aaa

Git 安装成功后会在根目录下创建各级目录，我创建了一个目录 project 用来存放我的代码工程。

二、创建 Git 仓库

1. 创建工程文件夹

mkdir GitLearner

2. 初始化一个新的 Git 仓库

cd GitLearner    // 进入工程文件夹
git init         // 初始化一个新的 Git 仓库

2.1 git init 命令的主要作用

1. 创建版本控制环境：在指定的目录中创建一个新的 Git 仓库，使其能够开始跟踪文件的变化。
2. 生成必要的结构：该命令在当前目录下创建一个名为 .git 的子目录，里面包含了所有的 Git 版本控制文件和历史记录。
3. 开始跟踪文件：一旦初始化完成，你可以使用其他 Git 命令（如 git add 和 git commit）开始跟踪和管理项目中的文件。

2.2 master 的意思

在 Git 中，master 是默认的分支名称，表示当前的主要开发分支。它通常是代码的稳定版本所在的分支。
解释：

1. 默认分支：当你初始化一个新的 Git 仓库（使用 git init），Git 会自动创建一个名为 master 的分支。
2. 主要开发分支：在许多开发工作流中，master 被用作主分支，所有的稳定功能和代码最终都会合并到这个分支上。
3. 分支名称变更：从 Git 2.28 版本开始，用户可以自定义默认的分支名称。在一些项目中，master 被替换为 main 或其他名称，以避免使用可能带有负面含义的术语。

三、本地仓库代码版本管理

1. 新建代码文件（示范用例）

touch code.c    // 创建 code.c 文件
ls              // 查看当前路径下的文件
vi code.c       // 使用 vi 编辑 code.c 文件
cat code.c      // 查看 code.c 的内容

2. 查看当前 Git 仓库的状态

2.1 git status 命令的主要功能

1. 显示当前分支：命令会告诉你当前所在的分支名称。
2. 未跟踪文件：显示哪些文件在工作目录中存在但没有被 Git 跟踪。
3. 已修改文件：列出已经修改但尚未添加（add）到暂存区的文件。
4. 已暂存文件：显示已经添加到暂存区，但还未提交（commit）的文件。
5. 合并状态：如果你正在进行合并操作，git status 会显示合并的状态信息及可能存在的冲突。

git status    // 显示当前 Git 仓库的状态

2.2 Git 仓库状态显示内容

1. 当前分支：你在 master 分支上。
2. 没有提交：目前没有任何提交记录。
3. 未跟踪文件：有一个名为 code.c 的文件是未跟踪的。这意味着 Git 并不知道这个文件的存在，因为它还没有被添加到版本控制中。

3. 将文件的更改添加到暂存区

3.1 暂存区

暂存区是一个中介区域，Git 用来准备即将提交的更改。

3.2 git add 命令的主要功能

1. 跟踪新文件：如果你创建了新的文件并希望 Git 开始跟踪它们，可以使用 git add 将这些文件添加到暂存区。
2. 更新已修改文件：对于已经在版本控制中的文件，git add 会将这些文件的最新更改添加到暂存区，以便在下次提交时记录这些更改。
3. 选择性添加：你可以选择性地添加特定的文件或目录，而不是一次性提交所有更改。这使得你可以精确控制每次提交的内容。

git add fileName.txt         // 添加单个文件
git add file1.txt file2.txt  // 添加多个文件
git add .                    // 添加所有更改
示范用例命令：
git add code.c               // 将文件的更改添加到暂存区

警告信息：表示在处理 code.txt 文件时，Git 将在下次操作时把行结束符从 LF 转换为 CRLF。
原因：这通常发生在 Windows 系统上，因为 Windows 使用 CRLF 作为行结束符，而 Unix/Linux 系统使用 LF。Git 会根据配置来处理行结束符，默认情况下在 Windows 上会将 LF 转换为 CRLF。
解决方法：
① 确认 Git 配置：
你可以使用以下命令查看当前 Git 的行结束符设置：

git config --global core.autocrlf

· 值为 true：在检出代码时，将 LF 转换为 CRLF；在提交时，CRLF 会转换为 LF。
· 值为 input：只在提交时转换，检出时不转换（适合 Unix/Linux 用户）。
· 值为 false：不进行任何转换。
② 根据需要调整设置：
如果你希望避免这种转换，可以设置 core.autocrlf 为 false：

git config --global core.autocrlf false

③ 忽略警告：
如果你不介意行结束符的变化，可以选择忽略这个警告。

4. 再次查看 Git 仓库状态

git status

4.1 Git 仓库状态显示内容

1. 当前分支：你在 master 分支上。
2. 没有提交：目前没有任何提交记录。
3. 待提交的更改：文件 code.c 已被添加到暂存区，准备进行提交。
   备注：这意味着你已经使用 git add code.c 命令将 code.c 文件标记为即将提交的文件。

5. 将暂存区中的更改保存到 Git 仓库中

git commit -m "Your commit message"  // 将暂存区中的更改保存到 Git 仓库中，形成一个新的提交

备注：每次提交都会创建一个快照，记录文件的当前状态，并为该快照生成一个唯一的 SHA-1 哈希值。
信息内容解释：

1. [master (root-commit) ea633ff]：
   · master：当前所在的分支名称。
   · (root-commit)：表示这是该分支的第一个提交（根提交）。
   · ea633ff：提交的哈希值（SHA-1），是这次提交的唯一标识符，但这是提交哈希值的缩写。
2. 1 file changed, 1 insertion(+)：
   · 表示有一个文件被更改，这里是指新创建的文件。
   · 1 insertion(+)：表示在该文件中增加了一行代码。
3. create mode 100644 code.c：
   · create mode 100644：表示创建了一个新的文件，并且其权限模式为 100644（普通的可读写文件）。
   · code.c：新创建的文件名。
   总结：这段输出表明你成功地提交了一个新文件 code.c，并且这是该项目的第一次提交。整个过程表明你已经成功地开始了使用 Git 来管理你的项目。

6. 查看提交历史

6.1 git log 命令的主要作用

1. 查看提交记录：显示当前分支的所有提交，包括每个提交的哈希值、作者、日期和提交信息。
2. 审计历史：用于跟踪项目的变更历史，帮助开发者了解代码的演变过程。
3. 查找特定提交：可以通过各种选项过滤或搜索特定的提交，例如按作者、日期或提交信息关键字。
4. 比较分支：通过与其他分支的日志比较，可以帮助了解不同分支之间的差异。
5. 支持多种格式：git log 支持多种输出格式，可以根据需要自定义显示的信息。
   常用选项：
   · --oneline：以简洁的一行格式显示每个提交。
   · --graph ：以图形方式展示分支和合并历史。
   · --author=：只显示特定作者的提交。
   · --since= / --until=：显示指定时间范围内的提交。

git log

注意：ea633ff28e85f72047b0af7e0f064bdf663d61bf 才是完整的提交哈希值，包含 40 个字符。当误删了某个提交后，可以使用这个完整 SHA 值来恢复内容，但使用缩写的 SHA 值不能恢复内容。

git log --oneline

注意：ea633ff 是缩写的 SHA 值。Git 默认使用前 7 个字符作为简短哈希值，这足以唯一标识该提交，尤其是在小型仓库中。
(HEAD -> master) 表示你当前位于 master 分支，并且此分支的最新提交是 ea633ff28e85f72047b0af7e0f064bdf663d61bf。

6.2 git reflog 命令的主要作用

git reflog 是用来记录所有引用变动历史的，包括提交、合并、重置等操作。如果想只查看提交的记录，可以通过一些额外的过滤和命令组合来实现。虽然 git reflog 本身没有直接的选项来只显示提交，但你可以使用 grep 来过滤输出。
只查看提交的记录

git reflog | grep 'commit'

7. 修改 code.c 文件并提交

备注：上述提到过的命令不再进行注释，便于巩固学习，加深印象。

7.1 修改内容

vi code.c    
cat code.c

7.2 提交 code.c

git status
git add code.c
git commit -m "第二次提交内容：Keep going!"
git log --oneline

8. 切换到指定的提交

8.1 使用 git reset --hard

git reset --hard ea633ff    // 重置到 SHA 为 ea633ff 的提交，可以是缩写的 SHA 值也可以是完整的 SHA 值
cat code.c

备注：
回退到第一次提交的版本后，我们查看 code.c 的内容，发现 code.c 的内容更新为第一次提交时的内容。
我们再切换到最新提交版本，也就是第二次提交，看看 code.c 的内容会发生什么变化。

备注：
实践结果发现，code.c 的内容又更新为第二次提交时的内容了。
注意事项：

• 数据丢失：
  使用 git reset --hard 是一种破坏性的操作。所有未提交的更改和已暂存的更改都将被永久删除，无法恢复。因此，在执行此命令之前，请确保没有需要保留的更改。
• 安全性：
  如果你不确定是否需要保留某些更改，可以先使用 git stash 来保存未提交的更改：

  git stash
  

  然后再执行 git reset --hard。

总结：
git reset --hard 用于将当前分支重置到指定的提交，并丢弃所有未提交的更改。它与切换到特定提交的功能相似，但更具有破坏性，因此在使用时需要特别小心。

8.2 使用 git checkout

可以通过提交的哈希值来切换到该提交的状态：

git checkout SHA

示例
假设要切换到提交哈希为 abc1234 的提交，命令如下：

git checkout abc1234

8.3 使用 git switch --detach

在较新的 Git 版本中，也可以使用 git switch 命令来切换到指定的提交：

git switch --detach SHA

示例
假设要切换到提交哈希为 abc1234 的提交，命令如下：

git switch --detach abc1234

注意事项

• Detached HEAD 状态：当你切换到一个具体的提交时，你的仓库将处于“detached HEAD”状态。这意味着你不再位于任何分支上，而是直接在一个特定的提交上。如果你在这个状态下进行新的提交，它们将不会在任何分支上，这可能导致难以找到这些提交。因此，如果你打算在这个提交上进行修改，建议创建一个新分支。

8.4 创建新分支

如果你需要在特定提交的基础上进行开发，建议创建一个新分支：

git checkout -b <new_branch_name> <commit_hash>
或者
git switch -b <new_branch_name> <commit_hash>

示例
例如，要在 abc1234 提交的基础上创建一个名为 new-feature 的新分支：

git checkout -b new-feature abc1234
或者
git switch -b new-feature abc1234

8.5 三者的区别

git reset --hard、git checkout 和 git switch 都可以用来切换到指定的提交或分支，但它们的作用、效果和适用场景各不相同。下面是这三者的详细比较：

① 基本功能

a. git checkout SHA

• 用途：切换到指定的提交或分支。
• 行为：
  ① 可以让你查看某个提交的状态。
  ② 如果切换到某个提交而不是分支，会进入游离头指针（detached HEAD）状态。
  ③ 在此状态下，可以查看文件的内容，但如果进行提交，将不在任何分支上，可能导致丢失工作。

b. git switch SHA

• 用途：主要用于切换分支（Git 2.23 及更高版本引入）。
• 行为：
  ① 可以用于切换到分支或提交，但通常用于切换到分支。
  ② 切换到提交时，同样会进入游离头指针状态。
  ③ 相较于 git checkout，git switch 更加明确，易于理解，因为它专注于切换分支。

c. git reset --hard SHA

• 用途：将当前分支重置到指定的提交，并丢弃所有未提交的更改。
• 行为：
  ① 将当前分支的 HEAD 移动到指定的提交。
  ② 会重置索引（暂存区）和工作目录到该提交的状态。
  ③ 所有自该提交以来的更改（包括未提交的和已暂存的）都会被丢弃。

② 影响范围

a. git checkout 和 git switch：

• 仅用于查看历史，默认不会影响当前分支的状态。
• 切换到某个提交后，如果你需要保留在该提交基础上的更改，应该创建新分支。

b. git reset --hard：

• 是一种破坏性操作，丢弃所有未提交的更改，实际改变了当前分支的历史。
• 重置后的结果是当前分支的 HEAD 将指向指定的提交，之后的所有提交记录将被移除（仅对当前分支有效，其他分支不受影响）。

③ 使用场景

a. git checkout SHA：

• 适合于临时查看某个提交的状态，或查看历史提交的文件内容。
• 如果你希望在该提交上进行一些修改，可以在游离状态下完成，但需小心处理。

b. git switch branch-name 或 git switch SHA：

• 适合于日常切换分支，使用更明确的语义。
• 当需要切换到特定提交时，虽然也进入游离状态，但推荐用于切换分支。

c. git reset --hard SHA：

• 当你希望丢弃所有自某个提交以来的更改，并重置工作目录和索引到该提交的状态时使用。
• 适合于清理代码状态，例如在错误提交后想要恢复到之前的干净状态。

④ 示例

a. 使用 git checkout ：

git checkout <commit-hash>

• 进入游离头指针状态，可以查看该提交的内容，但提交的更改不会关联到任何分支。

b. 使用 git switch ：

git switch <branch-name>  # 切换到指定分支
git switch <commit-hash>  # 切换到指定提交，进入游离状态

• 切换到分支时可以直接使用，切换到提交时同样进入游离状态。

c. 使用 git reset --hard ：

git reset --hard <commit-hash>

• 当前分支将重置到指定的提交，所有自该提交以来的更改都会丢失。

总结

• git checkout SHA 和 git switch SHA 都用于切换到特定的提交，可能会进入游离头指针状态，适合查看历史。
• git switch branch-name 更适合于切换分支，语义更清晰。
• git reset --hard SHA 是一种破坏性操作，适合用于重置当前分支的状态，丢弃所有未提交的更改。

8.6 当前有修改的情况下如何切换版本

① 使用 git stash 命令

更改 code.c 的内容：

git status
git stash        // 保存工作区的更改
git checkout SHA

保存了工作区的更改后，切换到指定的提交：

git log --oneline
git checkout SHA

查看切换后 code.c 的内容，再切换回主分支 master：

cat code.c
git checkout master    // 切换到名为 master 的分支
cat code.c

然后查看之前我们保存的更改，并恢复更改：

git status
git stash list                // 查看所有暂存的修改
git stash apply stash@{0}     // 恢复修改，但不删除 stash
cat code.c

git stash 主要功能：

1. 暂时保存当前改动：当你正在处理某些任务，但又需要切换到另一个分支进行其他操作时，可以使用 git stash 来保存当前的修改，这样就能将工作区和暂存区恢复到上次提交的干净状态。

2. 切换分支或进行其他操作：当你将当前的更改存放到 stash 中后，就可以自由地切换到其他分支，进行其他的开发任务，不会影响当前的修改。

3. 稍后恢复修改：你可以在任何时候恢复这些存储的修改，继续之前的工作。

git stash 的常见用法

1. 保存当前修改到堆栈

当你在当前工作区有未提交的修改（包括工作区和暂存区），可以使用 git stash 命令来暂存这些修改：

git stash

默认情况下，这会将工作区的修改和暂存区的修改都保存起来，并将工作区恢复到上次提交时的状态。

2. 查看所有存储的修改

如果你有多个 stash（多个暂存的修改），可以查看当前所有的 stash 条目：

git stash list

这将列出所有存储的 stash，显示每个 stash 的名称和对应的提交。

3. 恢复修改

要恢复最近一次的 stash，你可以使用：

git stash apply

这将把最新的 stash 恢复到你的工作区，但并不会从 stash 堆栈中删除该条目。

如果你想恢复特定的 stash（不是最新的），可以通过指定 stash 名称来恢复：

git stash apply stash@{2}

这里 stash@{2} 指的是第三个 stash 条目（stash@{0} 是最新的，stash@{1} 是倒数第二个，以此类推）。

4. 恢复并删除已应用的 stash

如果你恢复了 stash 的同时，还想把它从 stash 堆栈中删除，可以使用：

git stash pop

这不仅会恢复最近一次的 stash，还会将其从堆栈中移除。

5. 删除指定的 stash

如果你想删除某个 stash 条目，可以使用：

git stash drop stash@{2}

这会删除 stash@{2} 对应的 stash 条目。

6. 清空所有的 stash

如果你想删除所有的 stash 条目，可以使用：

git stash clear

这将会清除所有的 stash。

7. 仅存储工作区的修改或仅存储暂存区的修改

• 如果你只想保存工作区的修改，可以使用 git stash -k（或 --keep-index）：

  git stash -k
  

  这会将工作区的修改暂存起来，但保留暂存区的修改。

• 如果你只想保存暂存区的修改，可以使用 git stash -p：

  git stash -p
  

  这会将暂存区的修改暂存起来，但保留工作区的修改。

使用场景

1. 临时切换分支：
   假设你正在开发某个功能，但此时需要临时切换到其他分支处理一个紧急的 bug，你不希望提交中途的工作进度。可以使用 git stash 暂存当前工作，切换到其他分支，解决 bug 后再切回来恢复修改继续开发。

2. 保存修改以进行其他实验：
   如果你正在尝试某些改动，但还不确定是否会继续进行，你可以将当前修改暂存起来，进行其他实验或操作。如果实验失败，你可以恢复 stash 中的修改继续开发。

3. 清理工作区：
   在某些情况下，你可能需要清理工作区，以便进行某些操作。使用 git stash 保存当前修改后，你可以清理工作区，稍后再恢复这些修改。

总结

• git stash 允许你临时存储修改，不用提交或丢弃它们，可以轻松切换任务、分支。
• git stash apply 恢复修改，但不删除 stash。
• git stash pop 恢复修改并删除 stash。
• git stash list 查看所有暂存的修改。
• git stash drop 删除某个 stash。

② 使用 git restore 命令

git restore .    // 丢弃工作区的更改
git checkout SHA

9. 删除提交

9.1 使用 git reset

① 软重置（–soft）

如果你想删除最后的提交，但保留文件的更改在暂存区中，可以使用：

git reset --soft SHA   

这将删除最近的一次提交，并将更改保留在暂存区，以便你可以重新提交或修改。

② 混合重置（默认）

如果想删除提交并将更改移回工作区，可以使用：

git reset SHA

这将删除最近的一次提交，并将更改保留在工作区，方便你再次检查或修改。

③ 硬重置（–hard）

如果你想完全删除最近的提交以及所有更改，可以使用：

git reset --hard SHA

说明：

• 该命令将 HEAD 移动到上一个提交（SHA），并丢弃最近的提交及其所有更改。
• 使用 --hard 参数会丢弃工作目录中的所有未提交更改。

注意：这会丢失所有未保存的更改，因此请谨慎使用。

9.2 使用 git revert

如果你已经将提交推送到远程仓库，并且不想修改历史记录，建议使用 git revert 命令。这将创建一个新的提交，撤销指定提交的更改。

git revert SHA

说明：

• git revert 会创建一个新的提交，内容是撤销指定的提交。
• 适合用于已推送到公共分支的情况，因为它不会改变历史，而是新增一个提交。

9.3 使用 git rebase

俺目前用不来。

9.4 强制推送

如果你使用 git reset 或者 git rebase 删除了提交，并且已经将这些提交推送到远程仓库，你需要强制推送：

git push origin <branch_name> --force

注意：强制推送会覆盖远程仓库的历史，可能会影响其他开发者的工作，因此在进行此操作时请务必小心。

9.5 总结

对于公共仓库，推荐使用 git revert 来安全地撤销更改，而在私有仓库中可以使用 git reset 或 git rebase 来修改历史。## 10. 恢复删除的提交

10. 恢复删除的提交

10.1 提交一个新 code.c

vi code.c
git add code.c
git commit -m "第三次提交内容：I will delete it." 

10.2 删除最新的提交

• 查看历史提交记录：

git log --oneline

• 删除第三次提交：

git reset --hard 17691eb     

说明：执行该命令来重置到第二次提交，删除第三次提交及其所有更改。

10.3 恢复删除的最新提交

• 查看 reflog 日志：

git reflog | grep 'commit'

说明：使用 grep 过滤其他记录，只查看提交的记录。

• 找到丢失的提交，在输出中查找被删除的提交 SHA 值。
• 重置到该提交，使用找到的提交哈希：

git reset --hard e8722c5

11. 新建分支

11.1 查看本地分支

使用 git branch 命令不带任何参数时，它会列出当前本地仓库中的所有分支，并标注出当前所在的分支。当前分支会用 * 标注。

git branch

11.2 创建分支

git branch <branch-name> 用于创建一个新的分支，但不会自动切换到该分支。

git branch slave    // 创建一个名为 slave 的分支

11.3 重命名分支

1. 重命名当前分支
   如果你想要重命名你正在使用的分支，可以使用 git branch -m 命令。
   步骤：
   ① 确保你在要重命名的分支上（当前分支）。
   ② 执行以下命令来重命名当前分支：

git branch -m <new-branch-name>

2. 重命名非当前分支
   如果你想重命名一个你 没有切换到的分支，你可以使用相同的 git branch -m 命令，只需要指定旧的分支名和新的分支名。

git branch -m <old-branch-name> <new-branch-name>

12. 切换分支

在 Git 中，切换分支是一个常见的操作，可以使用 git checkout 或 git switch 命令。下面我将介绍这两种方法，及其相关的使用场景。

1. 使用 git checkout 切换分支

git checkout 是 Git 中传统的切换分支命令。它既可以用来切换分支，也可以用来恢复文件。

切换到已存在的分支

git checkout <branch-name>

例如，要切换到名为 slave 的分支：

git checkout slave

2. 使用 git switch 切换分支（推荐）

git switch 是 Git 在 2.23 版本中引入的新命令，专门用于切换分支。它的语义更明确，减少了与其他操作（如恢复文件）的混淆。git switch 现在是推荐的切换分支的方式。

切换到已存在的分支

git switch <branch-name>

例如，要切换到 slave 分支：

git switch slave

3. 创建并切换到新分支

如果你要创建一个新分支并且立即切换到它，git checkout 和 git switch 都可以做到这点。

使用 git checkout 创建并切换分支

git checkout -b <new-branch-name>

例如，创建并切换到 new-slave 分支：

git checkout -b new-slave

使用 git switch 创建并切换分支

git switch -c <new-branch-name>

例如，创建并切换到 new-slave 分支：

git switch -c new-slave

4. 查看当前分支

要查看当前所在的分支，可以使用以下命令：

git branch

当前分支前会有一个 * 标记。

5. 其他常见场景

切换分支时遇到未提交的修改

• 如果你有未提交的修改，Git 会提示你不能切换分支，因为可能会导致冲突。如果你希望暂时保存这些修改，可以使用 git stash 来 “暂存” 修改：

  git stash
  

  然后切换分支：

  git switch <branch-name>
  

  切换到目标分支后，可以使用 git stash pop 恢复之前暂存的修改：

  git stash pop
  

强制切换分支（丢弃修改）

如果你不想保留当前分支上的修改，可以使用 git checkout 或 git switch 的 --force 选项来强制切换分支，丢弃未提交的修改：

git checkout <branch-name> --force

或者：

git switch <branch-name> --discard-changes

总结

• git checkout <branch-name> 和 git switch <branch-name> 都可以用来切换到已存在的分支。
• git checkout -b <new-branch-name> 或 git switch -c <new-branch-name> 可以用来创建并切换到新分支。
• 推荐使用 git switch，因为它的语义更清晰、更简洁，专门用于切换分支。
• 切换分支时遇到未提交的修改，可以选择暂存（git stash）或强制切换。

13. 删除分支

使用 git branch -d <branch-name> 命令可以删除一个已经合并到当前分支的本地分支。

git branch -d slave

如果你确定要删除一个没有合并的分支，可以使用 -D（强制删除）选项：

git branch -D slave

举个例子：删除已合并的分支

假设我们有一个 Git 仓库，当前分支是 main，并且我们创建了一个新的分支 slave 来开发某个新特性。

1. 创建并切换到 slave 分支

git checkout -b slave

2. 在 slave 分支上进行一些提交

echo "New feature code" > feature.txt
git add feature.txt
git commit -m "Add new feature"

3. 切换回 main 分支

git checkout main

4. 合并 slave 分支到 main 分支

git merge slave

假设我们已经把 slave 分支上的内容成功合并到 main 分支。此时，我们想要删除 slave 分支。

5. 删除已经合并的分支

git branch -d slave

输出示例：

Deleted branch slave (was abc1234).

这时，slave 分支会被删除，因为它已经被完全合并到 main 分支中。

另一个例子：删除未合并的分支

假设 slave 分支的内容还没有合并到 main 分支，比如你还在 slave 分支上做了一些工作，但还没有合并到 main：

1. 切换到 main 分支

git checkout main

2. 尝试删除未合并的分支

git branch -d slave

此时，Git 会给出一个警告，告知该分支尚未合并到 main 分支，并且它不会删除该分支：

error: The branch 'slave' is not fully merged.
If you are sure you want to delete it, run 'git branch -D slave'.

总结

• git branch -d <branch-name>：用于删除一个已经 完全合并 到当前分支的本地分支。如果该分支有未合并的改动，Git 会阻止删除。
• 如果你确定要删除 未合并 的分支，可以使用 git branch -D <branch-name> 强制删除。

这样做的目的是避免你在删除分支时丢失尚未合并的工作。

14. 恢复删除的分支

恢复已删除的本地分支:
如果你删除了一个本地分支，但该分支的修改还没有丢失（例如，提交尚未被垃圾回收），你可以通过以下方式恢复它。

14.1 恢复已删除本地分支（通过 reflog）

Git 会记录分支的变动历史，包括分支删除的操作。你可以通过 git reflog 来查看最近的操作记录，然后恢复分支。

1. 查看 Git Reflog：

   git reflog
   

   git reflog 会列出所有对 HEAD 的操作历史，包括提交、分支切换、合并等。你应该能看到删除分支之前的提交记录，记下你想恢复的分支所在的提交哈希值（commit hash）。

   输出示例（部分）：

   1234567 HEAD@{0}: checkout: moving from slave to main
   89abcde HEAD@{1}: commit: added new feature
   

2. 恢复已删除分支：

   一旦找到了正确的提交哈希（假设是 1234567），你可以创建一个新的分支，并指向该提交哈希。

   git checkout -b <branch-name> <commit-hash>
   

   例如，要恢复 slave 分支：

   git checkout -b slave 1234567
   

   这会恢复你删除的分支，并将其指向之前的提交。

1.2 恢复已删除分支（通过 commit hash）

如果你知道你删除分支之前的最后一个提交的哈希值，也可以直接从那个提交恢复分支：

git branch <branch-name> <commit-hash>

例如：

git branch slave 1234567

这会创建一个新分支 slave，指向该提交。

本地仓库的代码版本管理笔记就到这里了，之后再学习远程仓库的管理。

ヾ(￣▽￣)Bye~Bye~