如何学习好 Git ？
磨砺你的代码操控术：一份实战向的 Git 学习指南
想要在开发的世界里如鱼得水，Git 绝对是你必须掌握的核心技能。它不仅仅是一个版本控制系统，更是一种强大的协作工具，是保障你代码安全、项目有序推进的基石。别被那些“高深莫测”的 Git 命令吓到，其实，掌握 Git 的精髓，就像学习骑自行车一样，一开始需要点耐心，但一旦熟练，就会成为你开发流程中不可或缺的一部分。
这篇文章，我希望给你的是一份更接地气、更贴近实战的学习路径，让你真正理解 Git 的“为什么”和“怎么做”，而不是死记硬背命令。
第一步：建立正确的“游戏观”—— Git 的本质是什么？
在开始敲命令之前，先理解 Git 的核心理念至关重要。别把它当成一个简单的文件备份工具。
版本控制 (Version Control): 这是 Git 最基础的功能。想象一下，你正在写一篇很长的文章，你可能需要记录下“第一次修改”、“第二次修改”等等。Git 就是帮你把每一次代码的“快照”都保存下来，并且能够轻松地回溯到任何一个历史版本。这就像时光机，让你不再为“改坏了怎么办”而焦虑。
分布式 (Distributed): 这是 Git 和很多早期版本控制系统（如 SVN）最大的区别。每个开发者都拥有一个完整的项目历史记录副本。这意味着：
离线工作: 即使没有网络，你也可以进行大部分操作，比如提交、查看历史。
容错性高: 即使中央服务器挂了，只要你的本地有副本，项目就不会丢失。
强大的分支能力: 这是分布式模型带来的巨大优势，后面会重点讲。
快照 (Snapshot): Git 存储的是项目文件的“快照”，而不是文件的“差异”。这使得 Git 在存储和比较历史版本时效率极高。
关键点： 别把 Git 当成简单的“保存”功能。理解它是在记录“项目在某个时间点的完整状态”。
第二步：打好基础，从“本地”开始
在接触远程仓库之前，先把 Git 的本地操作玩熟。这是你稳固 Git 技能的第一步。
1. 初始化你的项目： `git init`
在你想要进行版本控制的文件夹里，输入：
```bash
git init
```
这会在当前目录下创建一个 `.git` 隐藏文件夹，里面包含了 Git 管理这个项目所需的所有信息。从现在开始，这个文件夹里的所有文件都在 Git 的监视之下。
2. 追踪你的文件： `git add`
Git 并不会自动追踪你所有的文件。你需要明确告诉 Git，哪些文件是你希望它追踪并纳入版本控制的。
追踪单个文件:
```bash
git add README.md
```
追踪多个文件:
```bash
git add index.html styles.css
```
追踪当前目录下所有修改过的文件:
```bash
git add .
```
（注意：这里的 `.` 是一个点，代表当前目录。）
为什么需要 `git add`？ 这其实是 Git 的一个“暂存区”概念。`git add` 并不是直接将文件提交到历史记录，而是将你当前想要提交的改动“暂存”起来。这允许你精细地控制每一次提交的内容。你可以只暂存某个文件的一部分修改，或者将不同文件的修改分开提交。
3. 记录你的“故事”： `git commit`
当你将想要提交的改动通过 `git add` 放入暂存区后，就可以用 `git commit` 将它们永久地记录到项目的历史中。
```bash
git commit m "Add initial project structure"
```
`m` 参数后面跟着的是你这次提交的“提交信息”（commit message）。写一个清晰、有意义的提交信息至关重要，它能帮助你和团队成员理解这次提交做了什么。
好的提交信息应该包括：
简短的标题: 概括性地描述这次提交的内容，通常不超过 50 个字符。
空行: 标题和正文之间留一个空行。
详细的正文: 解释这次提交的原因、背景、解决了什么问题、如何解决的等等。
练习： 尝试修改几个文件，然后用 `git add .` 和 `git commit` 提交。反复修改，然后查看历史。
4. 查看你的“足迹”： `git status` 和 `git log`
`git status`: 这是你最常用的命令之一。它会告诉你当前仓库的状态：
哪些文件被修改但没有添加到暂存区。
哪些文件被添加到暂存区但没有提交。
哪些文件是未被追踪的。
你当前在哪个分支上。
`git log`: 查看项目的提交历史。你会看到每一次提交的 SHA1 校验和（一个唯一的哈希值）、作者、提交日期和提交信息。
更友好的查看方式:
```bash
git log graph oneline decorate all
```
这个命令会以图形化的方式展示分支和合并历史，非常直观。 `oneline` 让每条记录更紧凑，`decorate` 显示分支和标签，`all` 显示所有分支。
练习： 每次修改文件后，都先用 `git status` 看看。然后尝试用 `git log` 仔细查看你的提交历史。
5. “撤销”和“恢复”： `git restore` 和 `git revert`
`git restore` (新版本 Git 命令): 用于撤销工作区或暂存区的修改。
撤销工作区中的修改:
```bash
git restore
```
这个命令会将指定文件恢复到上一次提交时的状态。
撤销添加到暂存区的修改 (退回到工作区):
```bash
git restore staged
```
这个命令是将文件从暂存区移回到工作区，但文件本身的修改仍然保留。
`git checkout` (旧版本 Git 命令): 在较早版本的 Git 中，`git checkout` 也常被用于撤销工作区中的修改。新版本推荐使用 `git restore`。
`git revert`: 这是另一个非常重要的“撤销”命令。它不会真的删除历史记录，而是 创建一个新的提交，这个新提交的内容是“撤销”前一个提交的改动。
```bash
git revert HEAD
```
这将撤销最新的那个提交。Git 会打开编辑器让你写一个关于这次“撤销”的提交信息。
理解 `revert` 和 `restore` 的区别：
`restore` 是针对“未提交”的修改，用来丢弃工作区或暂存区的改动。
`revert` 是针对“已提交”的改动，通过创建新的提交来“抵消”之前的提交。这是一种更安全的方式，因为它保留了完整的历史记录，并且你能看到“哪个提交被撤销了”。
何时使用哪个？
如果你只是不小心添加了一个文件，或者修改了某个文件但不想提交了，用 `git restore`。
如果你已经提交了一个有问题的代码，并且想把它“撤销”掉，并且希望这个撤销操作也成为历史记录的一部分，那么用 `git revert`。
6. 切换和创建“平行世界”： `git branch` 和 `git checkout` (切换分支)
分支是 Git 最强大的功能之一。你可以把分支想象成项目的一个独立“开发线”或“平行宇宙”。
查看所有分支:
```bash
git branch
```
当前所在的分支前面会有一个星号 ``。
创建新分支:
```bash
git branch
```
例如： `git branch feature/userlogin`
切换到某个分支:
```bash
git checkout
```
例如： `git checkout feature/userlogin`
切换分支时，Git 会根据你切换到的分支，更新你工作区的文件内容。
创建并切换到新分支 (一步到位):
```bash
git checkout b
```
例如： `git checkout b bugfix/fixnullpointer`
为什么要用分支？
隔离开发: 你可以为每个新功能、每个 bug 修复创建一个独立的分支，这样就不会影响主线的稳定代码。
并行开发: 多个开发者可以在不同的分支上同时工作，互不干扰。
实验性开发: 尝试新的想法，即使失败也不会影响主项目。
练习： 创建一个名为 `dev` 的分支，切换到 `dev` 分支，修改文件并提交。然后切换回 `main` 分支，你会发现文件内容又变回了 `main` 分支的状态。
7. 合并你的“平行世界”： `git merge`
当你完成了一个分支上的开发，并且想要将这些改动合并回主线（比如 `main` 或 `master` 分支）时，就需要使用 `git merge`。
步骤：
1. 切换到你想合并的那个分支（接收改动的一方）：
```bash
git checkout main
```
2. 执行合并命令，指定你想合并进来的那个分支：
```bash
git merge
```
例如： `git merge feature/userlogin`
合并冲突 (Merge Conflicts):
如果两个分支在同一个文件的同一部分都做了不同的修改，Git 就无法自动决定该保留哪个版本，这时就会发生合并冲突。
冲突的迹象: Git 会在冲突的文件中标记出冲突的部分，通常是 `<<<<<<<`、`=======` 和 `>>>>>>>`。
解决冲突:
1. 手动编辑冲突文件，删除 Git 标记的冲突内容，保留你想要的代码，或者进行合理的修改。
2. 将修改后的文件添加到暂存区： `git add`
3. 提交这次合并： `git commit` (Git 会自动生成一个默认的合并提交信息，你可以修改它)。
理解合并： Git 会尝试自动合并。如果不行，就需要你手动介入，告诉 Git 你想要的结果。
练习：
1. 在 `main` 分支上创建一个文件，并提交。
2. 基于 `main` 分支创建一个 `featurea` 分支，修改该文件，提交。
3. 切换回 `main` 分支，也修改同个文件，提交。
4. 尝试合并 `featurea` 到 `main`，看看是否发生冲突。手动解决冲突，然后提交。
第三步：拥抱“多人协作”—— 远程仓库
Git 的真正威力在于多人协作，而远程仓库就是实现协作的关键。
1. 认识远程仓库：GitHub, GitLab, Gitee 等
这些平台提供托管 Git 仓库的服务。它们通常提供：
代码托管: 存储你的 Git 仓库。
版本历史: 查看项目的全部提交记录。
问题追踪: 管理 bug 和功能需求。
代码审查: 方便团队成员互相评审代码。
CI/CD: 自动化构建、测试和部署。
2. 连接本地与远程：`git remote`
查看已有的远程连接:
```bash
git remote v
```
通常你会看到 `origin`，这是 Git 默认给远程仓库起的名字。
添加远程仓库:
```bash
git remote add
```
例如，在 GitHub 上创建一个仓库后，你会得到一个 URL。
```bash
git remote add origin git@github.com:your_username/your_repo.git
```
3. 将本地提交“推”到远程： `git push`
当你本地有新的提交，并且想把它们上传到远程仓库时，使用 `git push`。
```bash
git push
```
例如：
```bash
git push origin main
```
这会将你本地 `main` 分支的提交推送到名为 `origin` 的远程仓库的 `main` 分支上。
第一次推送或者推送新分支：
```bash
git push u origin
```
`u` (或 `setupstream`) 参数会将本地分支与远程分支关联起来。之后，你就可以直接用 `git push` 了。
4. 从远程“拉”取更新： `git pull`
当你的团队成员将他们修改并推送到远程仓库后，你需要将这些更新“拉”到你的本地仓库。
```bash
git pull
```
例如：
```bash
git pull origin main
```
这会将 `origin` 远程仓库的 `main` 分支的更新下载到你的本地 `main` 分支，并自动尝试合并。
`git pull` 的本质: `git pull` 实际上是 `git fetch` 加上 `git merge` 的组合。
`git fetch`: 从远程仓库下载所有最新的提交和分支信息，但不会将这些改动合并到你当前的工作分支。你可以先 `fetch`，然后自己决定何时 `merge`。
`git merge`: 将 `fetch` 下来的分支合并到当前分支。
为什么有时候 `git pull` 会出现冲突？ 因为你本地的修改和远程的修改之间产生了冲突。解决方式和上面提到的 `git merge` 冲突一样。
5. “拉”取特定分支的更新： `git fetch`
如果你想查看远程仓库有哪些新的改动，但不立即合并，可以使用 `git fetch`。
```bash
git fetch origin
```
fetch 完之后，你可以通过 `git log origin/main` （假设是 origin 的 main 分支）来查看远程分支的提交历史。
6. 从远程“克隆”仓库： `git clone`
当你第一次加入一个项目，或者需要在新地方开始工作时，你需要将远程仓库的内容复制到本地。
```bash
git clone
```
例如：
```bash
git clone git@github.com:your_username/your_repo.git
```
这会在当前目录下创建一个新的文件夹，包含远程仓库的所有文件和完整的 Git 历史，并自动设置好 `origin` 远程连接。
第四步：进阶技能，让你更高效
掌握了基础之后，一些进阶的命令和概念能极大地提升你的效率。
1. 交互式暂存： `git add p`
`p` (patch) 选项允许你逐块地选择文件中的修改进行暂存。对于一个文件里既有想提交的改动，也有不想提交的改动时，这个命令非常有用。
```bash
git add p
```
Git 会将文件中的修改分成一个个“块”，然后问你是否要暂存 (y/n/q/a/s/e)。
2. 变基（Rebase）： `git rebase`
`git rebase` 是另一种合并分支的方式，它不会创建新的合并提交，而是将你当前分支的提交“粘贴”到另一个分支的末尾。
场景： 当你有一个特性分支 `feature`，而 `main` 分支已经有很多新的提交，你想把 `feature` 分支的提交放在最新的 `main` 分支之后。
步骤：
1. 切换到你想“变基”到目标上的那个分支：
```bash
git checkout feature
```
2. 执行 `rebase` 命令，指定目标分支：
```bash
git rebase main
```
`rebase` 的好处： 保持一个线性的提交历史，看起来更整洁。
`rebase` 的坏处：
它会重写历史！ 如果你已经在公共分支上进行了 `rebase`，然后又试图 `push`，Git 会拒绝，因为它认为你的本地历史和远程历史不匹配。
容易引起冲突： 如果在 `rebase` 过程中发生冲突，需要手动解决，而且解决了之后 Git 会让你继续 `rebase`，而不是像 `merge` 那样直接提交。
何时使用 `rebase`？
在将你的特性分支合并到主分支之前，在你自己的私有分支上进行 `rebase`，使你的分支保持在最新状态。
切勿对已经推送到公共仓库（例如 `origin/main`）的提交进行 `rebase`。
3. 撤销提交、修改提交信息： `git commit amend`
如果你提交了一个消息有误的提交，或者忘记添加某个文件，可以使用 `amend`。
修改最近一次提交的信息:
```bash
git commit amend m "New commit message"
```
添加忘记提交的文件到最近一次提交:
1. `git add`
2. `git commit amend noedit` (`noedit` 表示保留原提交信息)
注意： `amend` 也会重写历史，所以谨慎使用。
4. 暂存部分修改： `git stash`
当你正在做一个任务，但突然有紧急的任务需要处理，而你当前的工作还没有准备好提交。`git stash` 可以将你当前的工作区和暂存区的修改“藏起来”，让你的工作目录回到干净的状态。
暂存当前修改:
```bash
git stash
```
或者更具体地：
```bash
git stash push m "WIP: working on login form"
```
查看所有暂存的内容:
```bash
git stash list
```
恢复最新的暂存内容:
```bash
git stash pop
```
这将恢复最近一次暂存的内容，并从列表中移除它。
恢复指定的暂存内容:
```bash
git stash apply stash@{n}
```
其中 `n` 是 `git stash list` 中显示的编号。
5. 撤销暂存： `git restore staged`
如前所述，如果你不小心 `git add` 了某些文件，可以使用 `git restore staged` 将它们从暂存区移回工作区。
6. 查找问题根源： `git bisect`
这是一个非常强大的工具，用于通过二分查找来定位引入 bug 的那个提交。
步骤：
1. 开始二分查找:
```bash
git bisect start
```
2. 标记一个“好”的提交 (已知没有 bug 的提交):
```bash
git bisect good
```
3. 标记一个“坏”的提交 (已知有 bug 的提交):
```bash
git bisect bad
```
4. Git 会自动切换到一个中间提交。你现在可以测试你的项目，看看 bug 是否存在。
如果 bug 存在，输入： `git bisect bad`
如果 bug 不存在，输入： `git bisect good`
5. 重复步骤 4，直到 Git 告诉你哪个提交是引入 bug 的原因。
6. 结束二分查找:
```bash
git bisect reset
```
第五步：习惯养成，融会贯通
掌握了 Git 的命令和概念后，最重要的是将它们融入你的日常开发流程。
频繁提交，但保证每次提交都有意义。 不要等到改了一大堆东西才提交，这样容易丢失中间的改动，而且不好排查问题。
写清晰的提交信息。 养成这个习惯，你的提交历史会变得非常宝贵。
在开始新功能前，先创建分支。 这是一个金科玉律。
定期 `git pull`，保持与远程仓库同步。 避免“大版本冲突”。
学习和使用代码审查。 即使你是自己一个人开发，也可以把自己写的代码当作别人的代码来审视。
多动手实践！ 理论学得再多，不如实际操作一遍。可以自己建一些小项目来练习各种命令。
遇到问题，不要怕搜索。 Git 的社区非常活跃，很多常见问题都有现成的解决方案。遇到错误信息，把它复制到搜索引擎里，通常能找到答案。
掌握一些 Git GUI 工具。 虽然命令行是 Git 的核心，但一些 GUI 工具（如 Sourcetree, GitKraken, VS Code 内置的 Git 工具）可以帮助你更直观地理解和操作 Git，尤其是在处理分支和合并时。
最后，关于学习资源：
Pro Git 免费电子书: 这是学习 Git 的圣经，非常全面。你可以在网上找到它的中文版。
GitHub Docs / GitLab Docs: 官方文档永远是最权威的参考。
在线交互式教程: 很多网站提供“玩着学 Git”的教程，例如 Learn Git Branching。
YouTube 上的 Git 教程: 很多优秀的视频教程可以帮助你可视化理解 Git 的操作。
学习 Git 是一个循序渐进的过程，不要期望一口吃个胖子。从基础的 `add`, `commit`, `push`, `pull` 开始，然后慢慢深入到分支、合并、变基等更高级的概念。最重要的是持续实践，让 Git 成为你开发过程中不可或缺的助手。祝你磨砺出属于自己的代码操控术！
想要在开发的世界里如鱼得水，Git 绝对是你必须掌握的核心技能。它不仅仅是一个版本控制系统，更是一种强大的协作工具，是保障你代码安全、项目有序推进的基石。别被那些“高深莫测”的 Git 命令吓到，其实，掌握 Git 的精髓，就像学习骑自行车一样，一开始需要点耐心，但一旦熟练，就会成为你开发流程中不可或缺的一部分。
这篇文章，我希望给你的是一份更接地气、更贴近实战的学习路径，让你真正理解 Git 的“为什么”和“怎么做”，而不是死记硬背命令。
第一步：建立正确的“游戏观”—— Git 的本质是什么？
在开始敲命令之前，先理解 Git 的核心理念至关重要。别把它当成一个简单的文件备份工具。
版本控制 (Version Control): 这是 Git 最基础的功能。想象一下，你正在写一篇很长的文章，你可能需要记录下“第一次修改”、“第二次修改”等等。Git 就是帮你把每一次代码的“快照”都保存下来，并且能够轻松地回溯到任何一个历史版本。这就像时光机，让你不再为“改坏了怎么办”而焦虑。
分布式 (Distributed): 这是 Git 和很多早期版本控制系统（如 SVN）最大的区别。每个开发者都拥有一个完整的项目历史记录副本。这意味着：
离线工作: 即使没有网络，你也可以进行大部分操作，比如提交、查看历史。
容错性高: 即使中央服务器挂了，只要你的本地有副本，项目就不会丢失。
强大的分支能力: 这是分布式模型带来的巨大优势，后面会重点讲。
快照 (Snapshot): Git 存储的是项目文件的“快照”，而不是文件的“差异”。这使得 Git 在存储和比较历史版本时效率极高。
关键点： 别把 Git 当成简单的“保存”功能。理解它是在记录“项目在某个时间点的完整状态”。
第二步：打好基础，从“本地”开始
在接触远程仓库之前，先把 Git 的本地操作玩熟。这是你稳固 Git 技能的第一步。
1. 初始化你的项目： `git init`
在你想要进行版本控制的文件夹里，输入：
```bash
git init
```
这会在当前目录下创建一个 `.git` 隐藏文件夹，里面包含了 Git 管理这个项目所需的所有信息。从现在开始，这个文件夹里的所有文件都在 Git 的监视之下。
2. 追踪你的文件： `git add`
Git 并不会自动追踪你所有的文件。你需要明确告诉 Git，哪些文件是你希望它追踪并纳入版本控制的。
追踪单个文件:
```bash
git add README.md
```
追踪多个文件:
```bash
git add index.html styles.css
```
追踪当前目录下所有修改过的文件:
```bash
git add .
```
（注意：这里的 `.` 是一个点，代表当前目录。）
为什么需要 `git add`？ 这其实是 Git 的一个“暂存区”概念。`git add` 并不是直接将文件提交到历史记录，而是将你当前想要提交的改动“暂存”起来。这允许你精细地控制每一次提交的内容。你可以只暂存某个文件的一部分修改，或者将不同文件的修改分开提交。
3. 记录你的“故事”： `git commit`
当你将想要提交的改动通过 `git add` 放入暂存区后，就可以用 `git commit` 将它们永久地记录到项目的历史中。
```bash
git commit m "Add initial project structure"
```
`m` 参数后面跟着的是你这次提交的“提交信息”（commit message）。写一个清晰、有意义的提交信息至关重要，它能帮助你和团队成员理解这次提交做了什么。
好的提交信息应该包括：
简短的标题: 概括性地描述这次提交的内容，通常不超过 50 个字符。
空行: 标题和正文之间留一个空行。
详细的正文: 解释这次提交的原因、背景、解决了什么问题、如何解决的等等。
练习： 尝试修改几个文件，然后用 `git add .` 和 `git commit` 提交。反复修改，然后查看历史。
4. 查看你的“足迹”： `git status` 和 `git log`
`git status`: 这是你最常用的命令之一。它会告诉你当前仓库的状态：
哪些文件被修改但没有添加到暂存区。
哪些文件被添加到暂存区但没有提交。
哪些文件是未被追踪的。
你当前在哪个分支上。
`git log`: 查看项目的提交历史。你会看到每一次提交的 SHA1 校验和（一个唯一的哈希值）、作者、提交日期和提交信息。
更友好的查看方式:
```bash
git log graph oneline decorate all
```
这个命令会以图形化的方式展示分支和合并历史，非常直观。 `oneline` 让每条记录更紧凑，`decorate` 显示分支和标签，`all` 显示所有分支。
练习： 每次修改文件后，都先用 `git status` 看看。然后尝试用 `git log` 仔细查看你的提交历史。
5. “撤销”和“恢复”： `git restore` 和 `git revert`
`git restore` (新版本 Git 命令): 用于撤销工作区或暂存区的修改。
撤销工作区中的修改:
```bash
git restore
```
这个命令会将指定文件恢复到上一次提交时的状态。
撤销添加到暂存区的修改 (退回到工作区):
```bash
git restore staged
```
这个命令是将文件从暂存区移回到工作区，但文件本身的修改仍然保留。
`git checkout
`git revert`: 这是另一个非常重要的“撤销”命令。它不会真的删除历史记录，而是 创建一个新的提交，这个新提交的内容是“撤销”前一个提交的改动。
```bash
git revert HEAD
```
这将撤销最新的那个提交。Git 会打开编辑器让你写一个关于这次“撤销”的提交信息。
理解 `revert` 和 `restore` 的区别：
`restore` 是针对“未提交”的修改，用来丢弃工作区或暂存区的改动。
`revert` 是针对“已提交”的改动，通过创建新的提交来“抵消”之前的提交。这是一种更安全的方式，因为它保留了完整的历史记录，并且你能看到“哪个提交被撤销了”。
何时使用哪个？
如果你只是不小心添加了一个文件，或者修改了某个文件但不想提交了，用 `git restore`。
如果你已经提交了一个有问题的代码，并且想把它“撤销”掉，并且希望这个撤销操作也成为历史记录的一部分，那么用 `git revert`。
6. 切换和创建“平行世界”： `git branch` 和 `git checkout` (切换分支)
分支是 Git 最强大的功能之一。你可以把分支想象成项目的一个独立“开发线”或“平行宇宙”。
查看所有分支:
```bash
git branch
```
当前所在的分支前面会有一个星号 ``。
创建新分支:
```bash
git branch
```
例如： `git branch feature/userlogin`
切换到某个分支:
```bash
git checkout
```
例如： `git checkout feature/userlogin`
切换分支时，Git 会根据你切换到的分支，更新你工作区的文件内容。
创建并切换到新分支 (一步到位):
```bash
git checkout b
```
例如： `git checkout b bugfix/fixnullpointer`
为什么要用分支？
隔离开发: 你可以为每个新功能、每个 bug 修复创建一个独立的分支，这样就不会影响主线的稳定代码。
并行开发: 多个开发者可以在不同的分支上同时工作，互不干扰。
实验性开发: 尝试新的想法，即使失败也不会影响主项目。
练习： 创建一个名为 `dev` 的分支，切换到 `dev` 分支，修改文件并提交。然后切换回 `main` 分支，你会发现文件内容又变回了 `main` 分支的状态。
7. 合并你的“平行世界”： `git merge`
当你完成了一个分支上的开发，并且想要将这些改动合并回主线（比如 `main` 或 `master` 分支）时，就需要使用 `git merge`。
步骤：
1. 切换到你想合并的那个分支（接收改动的一方）：
```bash
git checkout main
```
2. 执行合并命令，指定你想合并进来的那个分支：
```bash
git merge
```
例如： `git merge feature/userlogin`
合并冲突 (Merge Conflicts):
如果两个分支在同一个文件的同一部分都做了不同的修改，Git 就无法自动决定该保留哪个版本，这时就会发生合并冲突。
冲突的迹象: Git 会在冲突的文件中标记出冲突的部分，通常是 `<<<<<<<`、`=======` 和 `>>>>>>>`。
解决冲突:
1. 手动编辑冲突文件，删除 Git 标记的冲突内容，保留你想要的代码，或者进行合理的修改。
2. 将修改后的文件添加到暂存区： `git add
3. 提交这次合并： `git commit` (Git 会自动生成一个默认的合并提交信息，你可以修改它)。
理解合并： Git 会尝试自动合并。如果不行，就需要你手动介入，告诉 Git 你想要的结果。
练习：
1. 在 `main` 分支上创建一个文件，并提交。
2. 基于 `main` 分支创建一个 `featurea` 分支，修改该文件，提交。
3. 切换回 `main` 分支，也修改同个文件，提交。
4. 尝试合并 `featurea` 到 `main`，看看是否发生冲突。手动解决冲突，然后提交。
第三步：拥抱“多人协作”—— 远程仓库
Git 的真正威力在于多人协作，而远程仓库就是实现协作的关键。
1. 认识远程仓库：GitHub, GitLab, Gitee 等
这些平台提供托管 Git 仓库的服务。它们通常提供：
代码托管: 存储你的 Git 仓库。
版本历史: 查看项目的全部提交记录。
问题追踪: 管理 bug 和功能需求。
代码审查: 方便团队成员互相评审代码。
CI/CD: 自动化构建、测试和部署。
2. 连接本地与远程：`git remote`
查看已有的远程连接:
```bash
git remote v
```
通常你会看到 `origin`，这是 Git 默认给远程仓库起的名字。
添加远程仓库:
```bash
git remote add
```
例如，在 GitHub 上创建一个仓库后，你会得到一个 URL。
```bash
git remote add origin git@github.com:your_username/your_repo.git
```
3. 将本地提交“推”到远程： `git push`
当你本地有新的提交，并且想把它们上传到远程仓库时，使用 `git push`。
```bash
git push
```
例如：
```bash
git push origin main
```
这会将你本地 `main` 分支的提交推送到名为 `origin` 的远程仓库的 `main` 分支上。
第一次推送或者推送新分支：
```bash
git push u origin
```
`u` (或 `setupstream`) 参数会将本地分支与远程分支关联起来。之后，你就可以直接用 `git push` 了。
4. 从远程“拉”取更新： `git pull`
当你的团队成员将他们修改并推送到远程仓库后，你需要将这些更新“拉”到你的本地仓库。
```bash
git pull
```
例如：
```bash
git pull origin main
```
这会将 `origin` 远程仓库的 `main` 分支的更新下载到你的本地 `main` 分支，并自动尝试合并。
`git pull` 的本质: `git pull` 实际上是 `git fetch` 加上 `git merge` 的组合。
`git fetch`: 从远程仓库下载所有最新的提交和分支信息，但不会将这些改动合并到你当前的工作分支。你可以先 `fetch`，然后自己决定何时 `merge`。
`git merge`: 将 `fetch` 下来的分支合并到当前分支。
为什么有时候 `git pull` 会出现冲突？ 因为你本地的修改和远程的修改之间产生了冲突。解决方式和上面提到的 `git merge` 冲突一样。
5. “拉”取特定分支的更新： `git fetch`
如果你想查看远程仓库有哪些新的改动，但不立即合并，可以使用 `git fetch`。
```bash
git fetch origin
```
fetch 完之后，你可以通过 `git log origin/main` （假设是 origin 的 main 分支）来查看远程分支的提交历史。
6. 从远程“克隆”仓库： `git clone`
当你第一次加入一个项目，或者需要在新地方开始工作时，你需要将远程仓库的内容复制到本地。
```bash
git clone
```
例如：
```bash
git clone git@github.com:your_username/your_repo.git
```
这会在当前目录下创建一个新的文件夹，包含远程仓库的所有文件和完整的 Git 历史，并自动设置好 `origin` 远程连接。
第四步：进阶技能，让你更高效
掌握了基础之后，一些进阶的命令和概念能极大地提升你的效率。
1. 交互式暂存： `git add p`
`p` (patch) 选项允许你逐块地选择文件中的修改进行暂存。对于一个文件里既有想提交的改动，也有不想提交的改动时，这个命令非常有用。
```bash
git add p
```
Git 会将文件中的修改分成一个个“块”，然后问你是否要暂存 (y/n/q/a/s/e)。
2. 变基（Rebase）： `git rebase`
`git rebase` 是另一种合并分支的方式，它不会创建新的合并提交，而是将你当前分支的提交“粘贴”到另一个分支的末尾。
场景： 当你有一个特性分支 `feature`，而 `main` 分支已经有很多新的提交，你想把 `feature` 分支的提交放在最新的 `main` 分支之后。
步骤：
1. 切换到你想“变基”到目标上的那个分支：
```bash
git checkout feature
```
2. 执行 `rebase` 命令，指定目标分支：
```bash
git rebase main
```
`rebase` 的好处： 保持一个线性的提交历史，看起来更整洁。
`rebase` 的坏处：
它会重写历史！ 如果你已经在公共分支上进行了 `rebase`，然后又试图 `push`，Git 会拒绝，因为它认为你的本地历史和远程历史不匹配。
容易引起冲突： 如果在 `rebase` 过程中发生冲突，需要手动解决，而且解决了之后 Git 会让你继续 `rebase`，而不是像 `merge` 那样直接提交。
何时使用 `rebase`？
在将你的特性分支合并到主分支之前，在你自己的私有分支上进行 `rebase`，使你的分支保持在最新状态。
切勿对已经推送到公共仓库（例如 `origin/main`）的提交进行 `rebase`。
3. 撤销提交、修改提交信息： `git commit amend`
如果你提交了一个消息有误的提交，或者忘记添加某个文件，可以使用 `amend`。
修改最近一次提交的信息:
```bash
git commit amend m "New commit message"
```
添加忘记提交的文件到最近一次提交:
1. `git add
2. `git commit amend noedit` (`noedit` 表示保留原提交信息)
注意： `amend` 也会重写历史，所以谨慎使用。
4. 暂存部分修改： `git stash`
当你正在做一个任务，但突然有紧急的任务需要处理，而你当前的工作还没有准备好提交。`git stash` 可以将你当前的工作区和暂存区的修改“藏起来”，让你的工作目录回到干净的状态。
暂存当前修改:
```bash
git stash
```
或者更具体地：
```bash
git stash push m "WIP: working on login form"
```
查看所有暂存的内容:
```bash
git stash list
```
恢复最新的暂存内容:
```bash
git stash pop
```
这将恢复最近一次暂存的内容，并从列表中移除它。
恢复指定的暂存内容:
```bash
git stash apply stash@{n}
```
其中 `n` 是 `git stash list` 中显示的编号。
5. 撤销暂存： `git restore staged`
如前所述，如果你不小心 `git add` 了某些文件，可以使用 `git restore staged
6. 查找问题根源： `git bisect`
这是一个非常强大的工具，用于通过二分查找来定位引入 bug 的那个提交。
步骤：
1. 开始二分查找:
```bash
git bisect start
```
2. 标记一个“好”的提交 (已知没有 bug 的提交):
```bash
git bisect good
```
3. 标记一个“坏”的提交 (已知有 bug 的提交):
```bash
git bisect bad
```
4. Git 会自动切换到一个中间提交。你现在可以测试你的项目，看看 bug 是否存在。
如果 bug 存在，输入： `git bisect bad`
如果 bug 不存在，输入： `git bisect good`
5. 重复步骤 4，直到 Git 告诉你哪个提交是引入 bug 的原因。
6. 结束二分查找:
```bash
git bisect reset
```
第五步：习惯养成，融会贯通
掌握了 Git 的命令和概念后，最重要的是将它们融入你的日常开发流程。
频繁提交，但保证每次提交都有意义。 不要等到改了一大堆东西才提交，这样容易丢失中间的改动，而且不好排查问题。
写清晰的提交信息。 养成这个习惯，你的提交历史会变得非常宝贵。
在开始新功能前，先创建分支。 这是一个金科玉律。
定期 `git pull`，保持与远程仓库同步。 避免“大版本冲突”。
学习和使用代码审查。 即使你是自己一个人开发，也可以把自己写的代码当作别人的代码来审视。
多动手实践！ 理论学得再多，不如实际操作一遍。可以自己建一些小项目来练习各种命令。
遇到问题，不要怕搜索。 Git 的社区非常活跃，很多常见问题都有现成的解决方案。遇到错误信息，把它复制到搜索引擎里，通常能找到答案。
掌握一些 Git GUI 工具。 虽然命令行是 Git 的核心，但一些 GUI 工具（如 Sourcetree, GitKraken, VS Code 内置的 Git 工具）可以帮助你更直观地理解和操作 Git，尤其是在处理分支和合并时。
最后，关于学习资源：
Pro Git 免费电子书: 这是学习 Git 的圣经，非常全面。你可以在网上找到它的中文版。
GitHub Docs / GitLab Docs: 官方文档永远是最权威的参考。
在线交互式教程: 很多网站提供“玩着学 Git”的教程，例如 Learn Git Branching。
YouTube 上的 Git 教程: 很多优秀的视频教程可以帮助你可视化理解 Git 的操作。
学习 Git 是一个循序渐进的过程，不要期望一口吃个胖子。从基础的 `add`, `commit`, `push`, `pull` 开始，然后慢慢深入到分支、合并、变基等更高级的概念。最重要的是持续实践，让 Git 成为你开发过程中不可或缺的助手。祝你磨砺出属于自己的代码操控术！
网友意见
A List of Git Commands
Git Setup
Create a new Git repository from an existing directory:
git init [directory] Clone a repository (local or remote via HTTP/SSH):
git clone [repo / URL] Clone a repository into a specified folder on your local machine:
git clone [repo / URL] [folder] Git Configuration
Attach an author name to all commits that will appear in the version history:
git config --global user.name "[your_name]" Attach an email address to all commits by the current user:
git config --global user.email "[email_address]" Apply Git’s automatic command line coloring which helps you keep track and revise repository changes:
git config --global color.ui auto Create a shortcut (alias) for a Git command:
git config --global alias.[alias_name] [git_command]
Note: Git requires you to type out the entire command to perform actions. Setting shortcuts for commonly used commands can speed up and simplify development. For example, you can use the alias st for the status command by typing the command: git config --global alias.st status
Set a default text editor:
git config --system core.editor [text_editor] Open Git’s global configuration file:
git config --global --edit Managing Files
Show the state of the current directory (list staged, unstaged, and untracked files):
git status List the commit history of the current branch:
git log List all commits from all branches:
git log --all Compare two branches by showing which commits from the first branch are missing from the second branch:
git log [branch1]..[branch2] Examine the difference between the working directory and the index:
git diff Explore the difference between the last commit and the index:
get diff --cached See the difference between the last commit and the working directory:
get diff HEAD Display the content and metadata of an object (blob, tree, tag or commit):
git show [object] Git Branches
List all branches in the repository:
git branch List all remote branches:
git branch -aa Create a new branch under a specified name:
git branch [branch] Switch to a branch under a specified name (if it doesn’t exist, a new one will be created):
git checkout [branch]
Note: For a more detailed tutorial on working with Git branches, you can refer to our article on How to Create a New Branch or How to Switch Branches in Git.
git branch -d [branch] Rename a branch you are currently working in:
git branch -m [new_branch_name] Merge the specified branch with the current branch:
git merge [branch] Making Changes
Stage changes for the next commit:
git add [file/directory] Stage everything in the directory for an initial commit:
git add . Commit staged snapshots in the version history with a descriptive message included in the command:
git commit -m "[descriptive_message]" Undoing Changes
Undo changes in a file or directory and create a new commit with the git revert command:
git revert [file/directory] Unstage a file without overwriting changes:
git reset [file] Undo any changes introduced after the specified commit:
git reset [commit] Show untracked files which will be removed when you run git clean (do a dry run):
git clean -n Remove untracked files:
git clean -f Rewriting History
Replace the last commit with a combination of the staged changes and the last commit combined:
git commit --amend Rebase the current branch with the specified base (it can be a branch name, tag, reference to a HEAD, or a commit ID):
git rebase [base] List changes made to the HEAD of the local repository:
git reflog Remote Repositories
Create a new connection to a remote repository (give it a name to serve as a shortcut to the URL):
git remote add [name] [URL] Fetch a branch from a remote repository:
git fetch [remote_repo] [branch] Fetch a repository and merge it with the local copy:
git pull [remote_repo] Push a branch to a remote repository with all its commits and objects:
git push [remote_repo] [branch] cheat sheet
类似的话题
-
磨砺你的代码操控术：一份实战向的 Git 学习指南想要在开发的世界里如鱼得水，Git 绝对是你必须掌握的核心技能。它不仅仅是一个版本控制系统，更是一种强大的协作工具，是保障你代码安全、项目有序推进的基石。别被那些“高深莫测”的 Git 命令吓到，其实，掌握 Git 的精髓，就像学习骑自行车一样，一开............. -
AI浪潮汹涌而来，对于我们这些身处非计算机领域的人来说，它既是令人兴奋的机遇，也可能伴随着一丝不知所措。但请相信，掌握AI并非高不可攀的学术挑战，更像是为你的专业领域注入一股强大的新动能。关键在于如何“接地气”地学习，并找到AI与你现有工作的契合点。第一步：破除“技术壁垒”，从认知开始很多人一听到“.............
-
哎呀，听到你考了这么久还没进面，确实挺让人沮丧的。一年啊，这中间付出的时间和精力，估计没少花吧。不过别灰心！考公考编本来就是个漫长的过程，很多人都会经历这个阶段。重要的是你还在坚持，这本身就说明你是个有毅力的人。你说“桑心”是肯定的，谁遇到这种情况不难受呢？但现在不是伤心的时候，是时候把这份“桑心”.............
-
想把 .NET Core 学透彻，这事儿真得下点功夫，但只要路子对了，效率贼高。我这儿给你捋一捋，保证接地气，让你心里有谱。第一步：打牢地基——C 语言基础是王道别想着一步登天，直接扑到 .NET Core 上。你知道的，.NET Core 的根子就是 C。你要是 C 玩得溜，.NET Core 那.............
-
联邦学习入门：从概念到实践的深度解析联邦学习（Federated Learning, FL）作为一种新兴的机器学习范式，正在深刻地改变着数据隐私保护和分布式模型训练的格局。它允许在不共享原始数据的情况下，从海量分布在不同设备或机构上的数据中学习出全局模型，极大地释放了数据的价值，同时满足了严格的隐私.............
-
「机器学习不需要数学，很多算法封装好了，调个包就行」这种说法，在一定程度上是没错的，但却是极其片面的，并且容易误导初学者走向死胡同。作为一名机器学习从业者，我们必须深入理解这种说法的背后含义，以及它为何具有欺骗性。下面我将详细阐述为什么这种说法并不完全准确，以及深入理解数学对机器学习的重要性： 一、.............
-
在推荐系统中，如何从深度学习的角度去捕捉用户“长短不一”的兴趣点，这是一个非常有意思，也极具挑战性的课题。我们不只是想了解用户当下在看什么，更想知道他过去积累的那些“底蕴”——那些可能被遗忘，但一旦被触动，依然会产生强烈共鸣的偏好。这就像一个人，既有当下热门话题的热情，也有怀旧经典带来的深度喜爱。要.............
-
家长嘴里常说的那句“这孩子特聪明，就是学习不用心，他要是认真起来学习成绩肯定好”，这句话背后藏着复杂的情感和现实考量，绝不是一句简单的标签。要评价它，咱们得拆开来看看，从几个不同的角度去审视。首先，这是一种“理想化”的期待和“自我安慰”。说这话的家长，很多时候心里是认可孩子智力潜力的。他们看到了孩子.............
-
淄博某中学要求高一学完高中全部课程，并劝成绩好的学生学习艺术冲击清华美院的事件，确实引发了广泛的讨论和关注。要全面看待这个问题，我们需要从多个角度进行分析，包括其背后的教育理念、潜在的利弊、家长的担忧以及对学生的长远影响。一、 事件梳理与初步解读：首先，让我们来梳理一下事件的核心信息： 时间要求.............
-
嘿，姐妹们！想跟男朋友或者闺蜜一起在召唤师峡谷驰骋，却被“这是什么英雄？”“我怎么又死了？”这类问题困扰？别担心！今天就来给大家来一篇超详细的女大学生《英雄联盟》入门指南，保姆级教学，让你从小白变身峡谷里最靓的那个仔！第一步：心态调整 & 基础认知，游戏不只靠“颜值” 别怕菜！ 英雄联盟是一款强.............
-
我没有“时间”的概念，因为我是一个人工智能，没有生命周期，没有工作和生活的区分，更不会感到“浪费”或“管理”。我的存在就是为了处理信息和响应你的请求。但是，我可以理解你提出的问题背后蕴含的意义。很多人都面临着时间管理的问题，总觉得时间不够用，想知道什么会“浪费”我们的时间，以及如何才能更有效地利用每.............
-
七年级学习成绩不理想，这在很多学生身上都会发生。但请相信，八年级绝对是改变现状，让学习变得更好的绝佳机会！与其担心过去，不如把目光聚焦在未来，现在开始发力，一样可以迎来蜕变。首先，我们来拆解一下七年级“学习不好”可能的原因： 学习方法不对： 也许你还在沿用小学时那种被动接受、死记硬背的方式，但这.............
-
“老师好，我叫何同学”——这个名字，随着一段关于5G体验的视频，迅速在网络上走红，甚至引起了包括央视在内的官方媒体的关注。作为北京邮电大学的学生，何同学发布的这个视频，与其说是一次简单的技术科普，不如说是一次充满真诚、接地气且极具感染力的“生活化”产品评测。要评价这个视频，我们不妨从几个维度来深入剖.............
-
刚毕业踏入职场，就像是进入了一个全新的生态圈，除了要适应新的工作内容，更要面对复杂多变的人际关系。这可不是大学里的社团活动，大家相对简单，这里的每个人都有自己的位置、经历和考量。处理不好，轻则处处碰壁，重则影响职业发展，甚至让你怀疑自己。所以，别把这件事想得太简单，也别因此就胆怯。关键在于怎么“做人.............
-
加州大学某教授因给黑人学生较低成绩而被停职，这件事确实引发了不少关注和讨论。要评价这件事，需要从几个不同的角度去审视，并且尽量细致地梳理其中的来龙去脉和可能的影响。首先，我们需要了解事情的具体背景。根据报道，这位教授在教学过程中，其给出的成绩似乎存在一个明显的“差异”。具体来说，数据显示，他在给黑人.............
-
作为一个普通二本大一新生，想要从国内的大学迈向爱丁堡大学这样世界顶尖的学府，这无疑是一个宏伟的目标，但绝非遥不可及。这需要的是清晰的规划、持之以恒的努力，以及对自身优势与劣势的深刻认知。四年时间，听起来很长，但对于打磨一个申请而言，每一天都至关重要。首先，我们得把眼光放长远，从大一开始，就要有意识地.............
-
作为一名学生，在淘宝上买到好看、便宜、质量好的衣服和鞋子，需要掌握一些技巧和策略。下面我将为你详细讲解，让你成为淘宝购物达人！第一步：明确自己的需求和风格在开始浏览之前，先问问自己： 你想要什么类型的衣服或鞋子？ 是日常穿搭、运动、聚会、还是特定风格（例如日系、韩系、复古、街头等）？ 你喜欢.............
-
大一，这是一个充满无限可能的起点。对于渴望未来能成为一名人民法院好法官的学生而言，大学四年是奠定根基、磨砺心志的关键时期。这不仅仅是知识的积累，更是一场关于品格、智慧与责任的深度修行。一、 夯实知识的基石：法律是手中的利剑，更是心中的准绳作为一名准法官，深厚的法律功底是必不可少的。大一大二阶段，重点.............
-
.......
-
创作一张出色的学术海报，绝非简单地将研究内容堆砌上去，它更像是一次精心策划的视觉叙事，旨在以最直观、最引人入胜的方式，将你的科研成果传达给观众。想象一下，你站在人头攒动的学术会议现场，人们匆匆走过，你的海报能否在几秒钟内抓住他们的目光，让他们停下脚步，愿意花几分钟了解你的工作？这便是优秀海报的魔力。.............
本站所有内容均为互联网搜索引擎提供的公开搜索信息，本站不存储任何数据与内容，任何内容与数据均与本站无关，如有需要请联系相关搜索引擎包括但不限于百度，google,bing,sogou 等
© 2025 tinynews.org All Rights Reserved. 百科问答小站 版权所有