Git团队协作完全入门指南（上）

Git团队协作完全入门指南（上）

你好！如果你是第一次听说Git，甚至对命令行都不太熟悉，不用担心。这篇教程会用最详细、最通俗的方式，手把手带你入门。我会假设你对这些东西完全不了解，从最基础的概念开始讲起。

这个博客的起因是我的好兄弟有问题，但是他觉得很多Git教程有点太抽象了。

第一章：在开始之前，你需要知道的事

1.1 什么是命令行？

在开始学Git之前，我们要先了解一个工具：命令行（也叫终端、控制台）。

什么是命令行？ 你平时用电脑，都是用鼠标点来点去对吧？比如双击文件夹打开它，右键删除文件等等。但还有另一种方式操作电脑：用文字命令。

想象一下：

• 图形界面：你对电脑说"请帮我打开这个文件夹"，你用鼠标双击
• 命令行：你对电脑说"请帮我打开这个文件夹"，你打字输入命令

为什么要用命令行？ 因为Git主要是通过命令行来使用的。一开始可能觉得不习惯，但其实命令行很强大，熟练后比鼠标点击还要快。

如何打开命令行？

• Windows：安装Git后，右键点击任意文件夹，选择"Git Bash Here"
• Mac：按 Command + 空格，输入"Terminal"（终端），按回车
• Linux：按 Ctrl + Alt + T

打开后，你会看到一个黑色或白色的窗口，里面有一些文字和一个闪烁的光标。不要害怕，这就是命令行！

1.2 命令行基础操作（5分钟速成）

在学Git之前，先学几个最基本的命令行操作：

1. 查看当前位置

pwd

这个命令会显示你现在在电脑的哪个文件夹里。比如显示 /Users/zhangsan/Desktop 就表示你在桌面。

2. 列出当前文件夹的内容

ls        # Mac/Linux
dir       # Windows

就像你在文件管理器里看到的文件列表一样。

3. 进入某个文件夹

cd 文件夹名字

比如：

cd Desktop      # 进入桌面
cd my-project   # 进入my-project文件夹

4. 返回上一级文件夹

cd ..

那两个点 .. 表示"父文件夹"。

5. 创建新文件夹

mkdir 文件夹名字

比如：

mkdir my-first-project    # 创建一个叫my-first-project的文件夹

小提示：

• 命令行里的路径用 / 分隔（不是Windows文件管理器里的 \）
• 文件夹名字如果有空格，要用引号括起来，比如 cd "My Project"
• 按上下箭头键可以查看之前输入过的命令

好了，有了这些基础，我们可以开始学Git了！

---

第二章：Git是什么？为什么要用它？

2.1 一个真实的故事

小明和他的三个朋友要一起做一个网站项目。刚开始，他们是这样协作的：

第一周：

• 小明写了首页的代码，保存为 website.html
• 他把文件发到微信群里
• 小红下载后，添加了导航栏，保存为 website-小红修改.html
• 小红又发到群里

第二周：

• 小刚也想改首页，但他不知道该用哪个文件，用小明的原始版本还是小红的版本？
• 小刚选择了小明的版本，加了个登录按钮，保存为 website-小刚修改.html
• 结果小红的导航栏丢失了！

第三周：

• 小明想把大家的修改合并起来，但文件有10个版本了：
  • website.html
  • website-小红修改.html
  • website-小刚修改.html
  • website-最终版.html
  • website-最终版2.html
  • website-这次真的是最终版.html
  • ...

小明崩溃了！他不知道哪个是最新的，哪些修改已经合并了，万一改错了也不知道怎么恢复。

2.2 Git是如何解决这个问题的？

如果他们用Git，故事会是这样的：

使用Git后：

• 所有人都在同一个项目上工作，不需要来回发文件
• 每个人的修改都被清楚记录：谁改的、什么时候改的、改了什么
• 可以轻松看到最新版本
• 如果改错了，可以一键恢复到任何历史版本
• 多个人同时修改不同部分，Git会自动合并
• 即使改了同一个地方，Git也会提醒你处理冲突

所以，Git就是一个：

1. 版本控制系统：记录文件的每一次修改
2. 协作工具：让多人可以同时在一个项目上工作
3. 时光机：可以回到过去的任何版本
4. 备份工具：你的代码永远不会丢失

2.3 Git的核心思想

Git的工作原理可以用一个比喻来理解：

想象你在写一本小说：

• 每写完一章，你拍个照片保存起来（这就是"提交/commit"）
• 照片按时间顺序排列，形成一个时间轴（这就是"历史记录"）
• 如果你想尝试不同的故事走向，可以复制出一个副本分支来写（这就是"分支/branch"）
• 写满意后，再把副本的内容合并回主线故事（这就是"合并/merge"）
• 你把所有照片传到云端，朋友们也能看到（这就是"推送到远程仓库/push"）

记住这个比喻，后面所有的概念都围绕着它展开。

---

第三章：安装和配置Git

3.1 下载和安装Git

Windows用户（最详细步骤）

1. 打开浏览器，访问 https://git-scm.com
2. 下载Git
   • 点击网站上显眼的"Download for Windows"按钮
   • 会自动下载一个 .exe 文件（大概50MB）
3. 安装Git
   • 双击下载的文件
   • 会弹出一个安装向导
   • 建议：一路点"Next"使用默认设置就可以了
   • 重要的几个选项：
     • "Select Components"：全选，不用管
     • "Adjusting your PATH environment"：选择 "Git from the command line and also from 3rd-party software"（通常是默认的）
     • "Choosing the default editor"：选择一个你喜欢的编辑器，不知道就选"Use Vim"
     • 其他都选默认即可
   • 点击"Install"开始安装
   • 安装完成后，点击"Finish"
4. 验证安装成功
   • 右键点击桌面或任意文件夹
   • 你会看到多了两个新选项："Git Bash Here" 和 "Git GUI Here"
   • 点击"Git Bash Here"
   • 会打开一个黑色窗口（这就是命令行）
   • 输入：git --version
   • 按回车
   • 如果显示类似 git version 2.43.0 的文字，说明安装成功了！

Mac用户

Mac系统可能已经自带了Git，我们先检查一下：

1. 打开终端
   • 按 Command (⌘) + 空格
   • 输入"Terminal"
   • 按回车
2. 检查是否已安装
   • 输入：git --version
   • 如果显示版本号，说明已经安装了
   • 如果提示"command not found"，继续下一步
3. 安装Git
   • 访问 https://git-scm.com
   • 下载Mac版本
   • 双击安装包，按照提示安装
   • 或者使用Homebrew安装（如果你知道这是什么）：brew install git

Linux用户

打开终端，根据你的发行版输入：

# Ubuntu/Debian
sudo apt-get update
sudo apt-get install git

# CentOS/RHEL
sudo yum install git

# Fedora
sudo dnf install git

安装完后，输入 git --version 验证。

3.2 第一次配置Git（非常重要！）

安装完Git后，你需要告诉Git你是谁。这很重要，因为每次你提交代码时，Git都会记录是谁提交的。

打开命令行（Git Bash或Terminal），输入以下两条命令：

git config --global user.name "你的名字"
git config --global user.email "你的邮箱"

详细说明：

1. git config 是配置Git的命令
2. --global 表示这是全局配置，对你电脑上所有的Git项目都有效
3. user.name 是你的用户名，可以是中文，比如"张三"
4. user.email 是你的邮箱，建议用你GitHub的邮箱（稍后会讲GitHub）

实际例子：

git config --global user.name "张三"
git config --global user.email "zhangsan@example.com"

输入完后，按回车。如果没有任何提示，说明设置成功了（Unix系统的哲学：没有消息就是好消息）。

验证配置：

git config --global --list

这会显示你的所有配置，应该能看到你刚才设置的名字和邮箱。

小提示：

• 这个名字和邮箱只是用来标识你的，不会被验证真实性
• 但如果你要用GitHub，建议邮箱和GitHub的注册邮箱一致
• 你随时可以重新运行这些命令来修改配置

---

第四章：Git的核心概念详解

在真正开始用Git之前，我们需要理解几个核心概念。这些概念非常重要，理解了它们，后面的操作就都说得通了。

4.1 仓库（Repository）

什么是仓库？

简单说，仓库就是一个被Git管理的文件夹。

你的项目文件夹里有很多文件，比如：

my-project/
  ├── index.html
  ├── style.css
  ├── script.js
  └── README.md

当你在这个文件夹里运行 git init 后，这个文件夹就变成了一个Git仓库。Git会创建一个隐藏文件夹 .git，里面存放了所有的版本历史信息。

仓库的作用：

• 跟踪文件夹里所有文件的变化
• 记录每一次修改的历史
• 允许你回到过去的任何版本

仓库的两种类型：

1. 本地仓库：在你自己的电脑上
2. 远程仓库：在服务器上（比如GitHub），大家都能访问

4.2 工作区、暂存区、版本库（超级重要！）

这是Git最重要也是最容易混淆的概念。我用一个详细的比喻来解释：

想象你在整理房间，准备拍照发朋友圈：

1. 工作区（Working Directory）
   • 就是你的房间本身
   • 你在这里移动东西、打扫卫生、装饰房间
   • 对应Git中，就是你的项目文件夹，你在这里修改代码
2. 暂存区（Staging Area / Index）
   • 想象你有一个"待拍照清单"
   • 你觉得沙发摆得不错，就在清单上打勾"沙发✓"
   • 你觉得书架也整理好了，再打勾"书架✓"
   • 但卧室还乱着呢，先不打勾
   • 对应Git中，你用 git add 把修改好的文件加入暂存区
3. 版本库（Repository）
   • 最后，你把清单上打勾的东西拍照，这张照片就永久保存了
   • 这张照片就存入了你的"照片册"
   • 对应Git中，你用 git commit 把暂存区的内容永久保存为一个版本

为什么要有暂存区这个中间环节？

假设你同时修改了10个文件，但你想分两次提交：

• 第一次提交：3个文件（它们是完成了登录功能的）
• 第二次提交：另外7个文件（它们是完成了注册功能的）

有了暂存区，你就可以：

# 只添加登录相关的文件到暂存区
git add login.html login.css login.js
git commit -m "完成登录功能"

# 再添加注册相关的文件
git add register.html register.css register.js signup.js form.js validation.js utils.js
git commit -m "完成注册功能"

这样，你的提交历史就很清晰，每次提交都是一个完整的功能。

文字图示：

工作区                 暂存区               版本库
(你修改文件)   →   (git add)   →   (git commit)
-----------------------------------------------------
修改 index.html        
修改 style.css    →   index.html      →   提交1: "更新首页"
修改 script.js         style.css
                      
修改 about.html   →   about.html      →   提交2: "添加关于页面"

4.3 提交（Commit）

什么是提交？

提交就是给你的项目拍一个快照，记录当前所有文件的状态。

每次提交都包含：

• 修改的内容：哪些文件被修改了
• 提交信息：描述这次修改做了什么（非常重要！）
• 作者信息：谁提交的（就是你之前配置的name和email）
• 时间戳：什么时候提交的
• 唯一ID ：一串字母和数字组成的编号（如 a3f5d9c）

提交的比喻：

把Git的提交历史想象成一条时间线上的珍珠链：

珠子1      →    珠子2      →    珠子3      →    珠子4
"初始化"   →   "添加首页"  →   "添加样式"  →   "修复bug"

每颗珠子就是一次提交，珠子按时间顺序连接起来。你可以随时跳到任何一颗珠子，看看那个时候的项目是什么样子。

好的提交信息 vs 坏的提交信息：

❌ 坏的例子：

"修改"
"更新代码"
"aaa"
"test"
"修复bug"  （不说是什么bug）

✅ 好的例子：

"添加用户登录功能"
"修复首页按钮点击无响应的问题"
"更新README文档，添加安装说明"
"重构数据库连接模块，提高性能"

为什么提交信息很重要？

想象3个月后，你发现网站有个bug，你查看提交历史，看到：

• 选项A："更新了一些东西" ← 完全不知道改了什么
• 选项B："修复了用户注册时邮箱验证失败的问题" ← 一目了然！

4.4 分支（Branch）

分支是Git最强大的功能之一，但对新手来说也是最难理解的。让我详细解释：

什么是分支？

分支就是项目的平行宇宙。你可以创建一个分支，在这个分支上做实验、开发新功能，而不影响主线代码。

详细比喻：

想象你在写一本小说，主线剧情是男主和女主A在一起了。但你想尝试一个不同的结局：男主和女主B在一起。

• 没有分支：你修改了结局，结果发现读者不喜欢，但你已经把原来的结局覆盖了，找不回来了。
• 有分支 ：
  1. 你创建一个"女主B结局"分支
  2. 在这个分支上写新结局
  3. 给读者看，如果他们喜欢，你就采用这个结局（合并分支）
  4. 如果他们不喜欢，你就删掉这个分支，主线故事完全没受影响

Git中的分支：

主分支 (main):
o---o---o---o---o
         \
          o---o  ← 新功能分支 (feature)

• 主分支 main（或叫 master）：是项目的主线，通常是稳定的、可发布的版本
• 功能分支 feature：从主分支分出来，开发某个新功能
• 开发完成后，可以把功能分支合并回主分支

实际应用场景：

假设你们团队在开发一个网站：

main 分支:         o---o---o---o---o---o---o  ← 始终保持可运行
                        \         \
feature-login:           o---o---o ← 张三在开发登录功能
                              \
feature-payment:               o---o---o ← 李四在开发支付功能

• 张三 创建 feature-login 分支，开发登录功能，完成后合并到 main
• 李四 创建 feature-payment 分支，开发支付功能，完成后合并到 main
• 两人互不干扰，各自在自己的分支上工作
• main 分支始终保持稳定，不会因为正在开发的功能而出问题

分支的好处：

1. 并行开发：多人可以同时开发不同功能
2. 安全实验：可以放心尝试新想法，不会破坏主代码
3. 代码审查：功能开发完成后，可以让别人审查再合并
4. 回滚方便：如果新功能有问题，直接删除分支即可

4.5 远程仓库（Remote Repository）

什么是远程仓库？

简单说，就是你的项目的云端备份，存放在服务器上（比如GitHub），大家都能访问。

本地仓库 vs 远程仓库：

你的电脑（本地仓库）          GitHub服务器（远程仓库）
    o---o---o                     o---o---o
         ↓                             ↑
    git push  →  --------→  ←  git pull
    （上传）                    （下载）

• 本地仓库：在你的电脑上，只有你能访问
• 远程仓库：在服务器上，团队所有人都能访问
• push（推送）：把本地的新提交上传到远程仓库
• pull（拉取）：把远程仓库的新提交下载到本地

为什么需要远程仓库？

1. 备份：万一你的电脑坏了，代码还在服务器上
2. 协作：团队成员可以互相看到对方的代码
3. 分享：可以让全世界的人看到你的项目（如果是公开仓库）
4. 持续集成：可以自动测试、自动部署

常见的远程仓库服务：

• GitHub：最流行的，全球最大的代码托管平台
• GitLab：功能强大，适合企业使用
• Gitee：中国的代码托管平台，访问速度快

我们主要会使用GitHub，因为它最流行。

---

第五章：创建你的第一个Git项目

理论讲完了，现在让我们实际操作！我会一步步带你创建第一个Git项目。

5.1 方式一：从零开始创建本地项目

这个方式适合你要开始一个新项目的情况。

步骤1：创建项目文件夹

首先，我们要创建一个文件夹来存放项目。

打开命令行（Git Bash或Terminal），输入以下命令：

# 进入你想存放项目的位置，比如桌面
cd ~/Desktop

# 创建一个新文件夹，叫my-first-project
mkdir my-first-project

# 进入这个文件夹
cd my-first-project

详细解释：

• cd ~/Desktop 表示进入桌面（~ 代表你的用户目录）
• mkdir my-first-project 创建一个新文件夹
• cd my-first-project 进入刚创建的文件夹

现在你在 my-first-project 文件夹里了，但这还只是个普通文件夹，不是Git仓库。

步骤2：初始化Git仓库

现在我们要把这个普通文件夹变成一个Git仓库：

git init

你会看到类似这样的提示：

Initialized empty Git repository in /Users/zhangsan/Desktop/my-first-project/.git/

发生了什么？

• Git在你的文件夹里创建了一个隐藏文件夹 .git
• 这个 .git 文件夹里存放了所有的版本历史信息
• 现在这个文件夹就是一个Git仓库了！

小提示：

• .git 文件夹是隐藏的，你可能在文件管理器里看不到
• 千万不要手动修改 .git 文件夹里的东西！ 这会破坏你的仓库
• 如果你想"取消"Git仓库，删除 .git 文件夹就行了（但通常不需要这样做）

步骤3：创建第一个文件

现在让我们创建一个文件：

echo "# 我的第一个Git项目" > README.md

这行命令做了什么？

• echo 是"回声"的意思，会输出后面的文字
• > 是重定向符号，把输出写入文件
• README.md 是文件名，.md 表示这是一个Markdown格式的文件

你也可以用文本编辑器手动创建这个文件：

• Windows：右键 → 新建 → 文本文档，重命名为 README.md
• Mac：用TextEdit或任何编辑器创建文件

在文件里写上：

# 我的第一个Git项目

这是我学习Git时创建的第一个项目。

## 项目介绍
这个项目用来练习Git的基本操作。

保存文件。

步骤4：查看状态

现在让我们看看Git认为发生了什么：

git status

你会看到类似这样的输出：

On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        README.md

nothing added to commit but untracked files present (use "git add" to track)

详细解释这段输出：

• On branch main ← 你在 main 分支上（主分支）
• No commits yet ← 你还没有做过任何提交
• Untracked files ← 有未跟踪的文件（Git还不知道要管理它们）
• README.md ← 这个文件是新的，Git还没有跟踪它
• 最后一行告诉你：用 git add 命令来跟踪这些文件

什么是"未跟踪"（Untracked）？

想象你买了一个新本子，在第一页写了字，但你还没有告诉图书管理员这个本子要放进图书馆管理。"未跟踪"就是这个意思：Git看到了这个文件，但你还没有告诉Git要管理它。

步骤5：添加文件到暂存区

现在让我们告诉Git要跟踪这个文件：

git add README.md

如果你有多个文件，可以一次性添加所有文件：

git add .

小提示：

• git add README.md ← 添加单个文件
• git add . ← 添加当前文件夹下的所有修改（最常用！）
• . 表示"当前文件夹"

现在再运行 git status 看看：

git status

输出变了：

On branch main

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   README.md

解释：

• Changes to be committed ← 准备提交的修改
• new file: README.md ← 这是一个新文件

文件从"未跟踪"变成了"准备提交"，它现在在暂存区了！

步骤6：提交到版本库

现在让我们做第一次提交：

git commit -m "初始化项目，添加README文件"

输出类似这样：

[main (root-commit) a3f5d9c] 初始化项目，添加README文件
 1 file changed, 5 insertions(+)
 create mode 100644 README.md

详细解释：

• git commit ← 提交命令
• -m "..." ← -m 表示"message"（消息），后面跟你的提交说明
• [main (root-commit) a3f5d9c] ← 在main分支上，这是第一次提交（root-commit），ID是a3f5d9c
• 1 file changed ← 1个文件被修改
• 5 insertions(+) ← 插入了5行内容

恭喜！你完成了第一次提交！

现在再运行 git status：

git status

输出：

On branch main
nothing to commit, working tree clean

解释：

• nothing to commit ← 没有需要提交的修改
• working tree clean ← 工作区是干净的（没有未保存的修改）

这说明所有的修改都已经提交了！

步骤7：查看提交历史

现在让我们看看提交历史：

git log

输出类似这样：

commit a3f5d9c8b2e1f4d6a8c9e7f5d3b1a9c7e5d3b1a  (HEAD -> main)
Author: 张三 <zhangsan@example.com>
Date:   Mon Dec 23 10:30:00 2024 +0800

    初始化项目,添加README文件

详细解释：

• commit a3f5d9c... ← 这次提交的唯一ID（很长的一串）
• (HEAD -> main) ← HEAD指向main分支（HEAD表示"当前位置"）
• Author ← 作者（你之前配置的名字和邮箱）
• Date ← 提交时间
• 最后是你的提交信息

小提示：

• git log 显示详细历史
• git log --oneline 显示简洁版本（推荐！）
• 按 q 键退出日志查看

试试简洁版本：

git log --oneline

输出：

a3f5d9c (HEAD -> main) 初始化项目，添加README文件

简洁多了！

5.2 方式二：克隆一个已存在的项目

这个方式适合你要加入一个已有的项目的情况。

假设你的队友已经在GitHub上创建了一个项目，地址是：

https://github.com/yourteam/awesome-project.git

你想把这个项目下载到本地，只需要一个命令：

# 进入你想存放项目的文件夹
cd ~/Desktop

# 克隆项目
git clone https://github.com/yourteam/awesome-project.git

# 进入项目文件夹
cd awesome-project

发生了什么？

• Git从GitHub下载了整个项目
• 自动初始化了本地Git仓库
• 自动建立了和远程仓库的连接
• 下载了所有的历史记录

一个命令就搞定了！不需要再 git init，因为已经是个Git仓库了。

---

第六章：Git的日常工作流程

现在你已经有了一个Git项目，让我们学习日常工作中最常用的操作流程。

6.1 完整的工作流程（重要！）

记住这个流程，以后每天工作都会用到：

1. 修改文件（在工作区）
      ↓
2. git add .（添加到暂存区）
      ↓
3. git commit -m "..."（提交到版本库）
      ↓
4. git push（推送到远程仓库，如果有的话）

这就像一个生产线：

1. 在工厂里生产零件（修改文件）
2. 把零件放到待检区（git add）
3. 质检通过，打包装箱（git commit）
4. 发货到仓库（git push）

6.2 实际操作演练

让我们做一个完整的工作流程演练：

场景：给项目添加一个新功能

步骤1：修改文件

假设你要添加一个 index.html 文件。用你喜欢的编辑器创建文件：

<!DOCTYPE html>
<html>
<head>
    <title>我的第一个网页</title>
</head>
<body>
    <h1>欢迎来到我的网站！</h1>
    <p>这是我用Git管理的第一个网页项目。</p>
</body>
</html>

保存文件。

步骤2：查看状态

git status

输出：

On branch main
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        index.html

nothing added to commit but untracked files present (use "git add" to track)

Git发现了新文件 index.html，但它还是"未跟踪"状态。

步骤3：添加到暂存区

git add index.html

或者添加所有修改：

git add .

步骤4：再次查看状态

git status

输出：

On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   index.html

现在文件在暂存区了，准备提交！

步骤5：提交

git commit -m "添加首页index.html"

输出：

[main b7d8a2f] 添加首页index.html
 1 file changed, 10 insertions(+)
 create mode 100644 index.html

完成！你的修改已经被永久保存了。

步骤6：查看历史

git log --oneline

输出：

b7d8a2f (HEAD -> main) 添加首页index.html
a3f5d9c 初始化项目，添加README文件

现在有两次提交了！

6.3 修改已有文件

现在让我们修改已经存在的文件：

步骤1：编辑 index.html

打开 index.html，添加一段内容：

<!DOCTYPE html>
<html>
<head>
    <title>我的第一个网页</title>
</head>
<body>
    <h1>欢迎来到我的网站！</h1>
    <p>这是我用Git管理的第一个网页项目。</p>
    <p>这是新添加的内容！</p> <!-- 这是新加的 -->
</body>
</html>

保存。

步骤2：查看状态

git status

输出：

On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   index.html

no changes added to commit (use "git add" and/or "git commit -a")

解释：

• Changes not staged for commit ← 有修改，但还没放到暂存区
• modified: index.html ← 这个文件被修改了

步骤3：查看具体修改了什么

git diff

输出类似这样：

diff --git a/index.html b/index.html
index e5f3d9a..7d8a2bf 100644
--- a/index.html
+++ b/index.html
@@ -6,5 +6,6 @@
 <body>
     <h1>欢迎来到我的网站！</h1>
     <p>这是我用Git管理的第一个网页项目。</p>
+    <p>这是新添加的内容！</p>
 </body>
 </html>

解释：

• 绿色的 + 开头的行是新增的内容
• 红色的 - 开头的行是删除的内容（这里没有）

按 q 退出查看。

步骤4：添加和提交

git add index.html
git commit -m "在首页添加新段落"

或者用一个快捷方式（适用于修改已跟踪的文件）：

git commit -am "在首页添加新段落"

说明：

• -a 选项会自动把所有已跟踪的文件的修改加入暂存区
• -m 后面跟提交信息
• -am 就是把两个选项合并了

但是注意：-a 只对已经被Git跟踪的文件有效，新文件还是要先 git add。

6.4 删除文件

假设你想删除一个文件：

方法1：直接删除文件，然后告诉Git

rm index.html          # 删除文件（Unix/Mac）
del index.html         # 删除文件（Windows CMD）
git add index.html     # 告诉Git这个删除操作
git commit -m "删除index.html"

方法2：用Git命令删除（推荐）

git rm index.html
git commit -m "删除index.html"

git rm 命令会同时删除文件并告诉Git，一步到位。

6.5 重命名文件

假设你想把 index.html 改名为 home.html：

方法1：手动改名，然后告诉Git

mv index.html home.html    # 重命名（Unix/Mac）
git add home.html
git add index.html
git commit -m "重命名index.html为home.html"

方法2：用Git命令重命名（推荐）

git mv index.html home.html
git commit -m "重命名index.html为home.html"

一步到位！

6.6 忽略某些文件

有些文件我们不想提交到Git，比如：

• 编译生成的文件
• 临时文件
• 包含密码的配置文件
• 系统文件（如Mac的 .DS_Store）
• 依赖包文件夹（如 node_modules/）

如何忽略文件？

创建一个 .gitignore 文件：

touch .gitignore

编辑这个文件，添加要忽略的文件或文件夹：

# 忽略所有.log文件
*.log

# 忽略临时文件夹
temp/
tmp/

# 忽略Mac系统文件
.DS_Store

# 忽略Node.js的依赖包
node_modules/

# 忽略配置文件中的敏感信息
config/secrets.txt

然后提交 .gitignore：

git add .gitignore
git commit -m "添加.gitignore文件"

现在，.gitignore 里列出的文件就不会被Git跟踪了。

---

第七章：分支操作详解

分支是Git最强大的功能，也是团队协作的核心。让我们详细学习分支的使用。

7.1 为什么需要分支？（再次强调）

想象一个真实场景：

你们团队在开发一个电商网站：

• 网站现在是v1.0版本，正在线上运行
• 你要开发一个新功能：购物车
• 这个功能需要2周时间
• 但在这2周里，可能会有紧急bug需要修复

没有分支的情况：

• 你在主代码上开发购物车功能
• 第3天，发现了一个紧急bug
• 但你的购物车功能还没完成，代码是半成品
• 你无法发布修复，因为会把半成品购物车也发布了
• 你进退两难！

有分支的情况：

main分支（稳定）:     o---o---o---o---o---o
                          \         \
feature-cart分支:          o---o---o  ← 你在这里开发购物车
                                \
hotfix分支:                      o  ← 紧急修复bug

• 你创建 feature-cart 分支开发购物车
• 发现紧急bug时，从 main 分支创建 hotfix 分支
• 在 hotfix 分支上修复bug，然后合并回 main 并发布
• 购物车功能不受影响，继续在 feature-cart 分支上开发
• 完成后再合并回 main

7.2 查看分支

查看所有本地分支：

git branch

输出：

* main

* 号表示你当前在哪个分支上。

查看所有分支（包括远程分支）：

git branch -a

7.3 创建分支

创建一个新分支：

git branch feature-login

这会创建一个叫 feature-login 的分支，但你还在 main 分支上。

验证：

git branch

输出：

  feature-login
* main

看到了吧，有两个分支了，但 * 还在 main 上。

7.4 切换分支

切换到新分支：

git checkout feature-login

或者用新命令（Git 2.23+）：

git switch feature-login

输出：

Switched to branch 'feature-login'

验证：

git branch

输出：

* feature-login
  main

现在 * 在 feature-login 上了！

创建并切换分支（快捷方式）：

git checkout -b feature-payment

或者：

git switch -c feature-payment

这一个命令相当于：

git branch feature-payment    # 创建分支
git checkout feature-payment  # 切换过去

7.5 在分支上工作

现在你在 feature-login 分支上，让我们添加一个登录页面：

创建 login.html：

<!DOCTYPE html>
<html>
<head>
    <title>登录</title>
</head>
<body>
    <h1>用户登录</h1>
    <form>
        <input type="text" placeholder="用户名">
        <input type="password" placeholder="密码">
        <button>登录</button>
    </form>
</body>
</html>

提交：

git add login.html
git commit -m "添加登录页面"

现在切回 main 分支：

git checkout main

神奇的事情发生了：

打开你的项目文件夹，login.html 消失了！

再切回 feature-login 分支：

git checkout feature-login

login.html 又出现了！

这就是分支的魔法：

• 每个分支有自己独立的文件状态
• 切换分支时，工作区的文件会自动变化
• 就像在不同的平行宇宙之间穿梭

7.6 合并分支

当你在 feature-login 分支上完成了登录功能，想把它合并到 main 分支：

步骤1：切换到目标分支（main）

git checkout main

记住：要合并到哪个分支，就先切换到哪个分支。

步骤2：合并

git merge feature-login

输出：

Updating a3f5d9c..e8f2a7b
Fast-forward
 login.html | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 login.html

解释：

• Fast-forward ← 这是一种合并模式，表示"快进"
• login.html | 13 +++++++++++++ ← 添加了13行代码

现在，login.html 在 main 分支上也有了！

步骤3：删除已合并的分支（可选）

如果 feature-login 分支已经完成使命，可以删除它：

git branch -d feature-login

输出：

Deleted branch feature-login (was e8f2a7b).

小提示：

• -d 是安全删除，如果分支还没合并，Git会警告你
• -D 是强制删除，不管有没有合并都删除（危险！）

7.7 合并冲突（重要！）

当两个分支修改了同一个文件的同一部分，合并时就会发生冲突。这是团队协作中最常见的情况，不要害怕它！

什么时候会发生冲突？

场景模拟：

1. 你和同事小王都从 main 分支创建了自己的分支
2. 你们两人都修改了 index.html 的第10行
3. 小王先完成并合并到了 main
4. 当你也想合并时，Git发现第10行有两个不同的版本
5. Git不知道该保留谁的，于是报告冲突，让你来决定

实际演练：制造一个冲突

让我们实际操作一遍，这样你就知道怎么处理了。

步骤1：创建两个分支

先在 main 分支上创建一个文件：

git checkout main
echo "这是原始内容" > test.txt
git add test.txt
git commit -m "添加test.txt"

创建第一个分支并修改文件：

git checkout -b branch-a
echo "这是分支A的修改" > test.txt
git commit -am "分支A修改test.txt"

回到 main，创建第二个分支并修改同一个文件：

git checkout main
git checkout -b branch-b
echo "这是分支B的修改" > test.txt
git commit -am "分支B修改test.txt"

步骤2：先合并分支A

git checkout main
git merge branch-a

没问题，合并成功！

步骤3：尝试合并分支B（冲突来了！）

git merge branch-b

你会看到：

Auto-merging test.txt
CONFLICT (content): Merge conflict in test.txt
Automatic merge failed; fix conflicts and then commit the result.

翻译：

• 自动合并 test.txt
• 冲突！test.txt 的内容有冲突
• 自动合并失败，请修复冲突然后提交结果

不要慌！ 这很正常，我们来解决它。

步骤4：查看冲突

打开 test.txt 文件，你会看到：

<<<<<<< HEAD
这是分支A的修改
=======
这是分支B的修改
>>>>>>> branch-b

详细解释：

• <<<<<<< HEAD 到 ======= 之间：是当前分支（main，已经合并了branch-a）的内容
• ======= 到 >>>>>>> branch-b 之间：是要合并进来的分支（branch-b）的内容
• Git用这些符号把两个版本都展示给你，让你决定保留哪个

步骤5：解决冲突

你有三个选择：

1. 保留分支A的内容：删除分支B的部分和所有标记符号
2. 保留分支B的内容：删除分支A的部分和所有标记符号
3. 两个都保留或写一个新的：删除标记符号，手动编辑

假设我们两个都保留，编辑文件为：

这是分支A的修改
这是分支B的修改

一定要删除那些 <<<<、====、>>>> 符号！

步骤6：标记冲突已解决

保存文件后，告诉Git冲突已解决：

git add test.txt

步骤7：完成合并

git commit -m "合并branch-b，解决冲突"

或者直接 git commit（不加 -m），Git会自动生成一个合并提交信息。

完成！ 冲突解决了！

冲突解决的建议

1. 不要害怕冲突：这是正常的，说明团队在协作
2. 仔细阅读冲突内容：理解两个版本的区别
3. 和相关同事沟通：如果不确定保留哪个，问问对方
4. 测试解决后的代码：确保合并后的代码能正常工作
5. 经常从main拉取更新：减少冲突的可能性

7.8 分支管理的最佳实践

分支命名规范：

• feature/功能名：开发新功能，如 feature/user-login
• bugfix/bug描述：修复bug，如 bugfix/header-overlap
• hotfix/紧急修复：紧急修复线上问题
• release/版本号：准备发布的版本

团队分支策略（简化版）：

• main 分支：永远保持稳定，可以随时发布
• develop 分支：开发分支，功能开发完成后合并到这里
• feature/* 分支：个人开发分支，从develop创建，完成后合并回develop
• 定期把develop合并到main进行发布

---