Files

T

Serendipity 86514309cf feat: Enhance sync status view with filtering and improved UI

- Updated workspace configuration for better tab management.
- Added new localization strings for sync status and post details in English, Simplified Chinese, and Traditional Chinese.
- Refactored sync status view to include filtering options (all, synced, pending) and improved post grouping by category.
- Enhanced post card rendering with detailed information and action buttons for update, publish, and pull.
- Implemented a modal for viewing sync history with clear history functionality.
- Improved styling for better user experience across various components.
- Added metadata to Git团队协作指南大纲.md for Halo integration.

2026-04-28 18:32:42 +08:00

59 KiB

Raw Permalink Blame History

title, slug, cover, categories, tags, halo

title

slug

cover

《Git团队协作指南：从入门到精通》详细写作大纲

预计总字数：20000字以上 目标读者：有一定编程基础，需要团队协作参赛的同学 代码语言：Python为主（适当对比Shell命令） 侧重点：命令讲解（30%）+ 实操演示（40%）+ 理论说明（30%）

📊 整体结构概览

章节	标题	预计字数	侧重点
第一章	引言：为什么比赛团队需要Git？	1500字	理论说明
第二章	基础概念：理解Git的核心思想	2000字	理论说明
第三章	实战入门：Git基本操作	3000字	命令讲解+实操
第四章	分支管理：团队协作的核心	3500字	命令讲解+实操
第五章	团队协作流程：从开发到发布	4000字	实操演示
第六章	冲突处理：化干戈为玉帛	2500字	命令讲解+实操
第七章	比赛场景实战：三人团队的协作范例	3000字	实操演示
第八章	实用技巧与常见问题	2000字	命令讲解
第九章	总结与进阶学习路线	1500字	理论说明
附录	命令速查表与资源推荐	1000字	命令讲解

总计：约24000字（超出目标，留有调整空间）

📝 第一章：引言（1500字）

1.1 场景引入：从一场灾难说起（400字）

内容要点：

讲述一个典型的团队协作灾难场景（代码冲突、版本混乱、覆盖丢失）
模拟小明、小红、小刚三人团队开发比赛项目的场景
展示没有版本控制时的各种问题

痛点列举：

❌ "我写的代码去哪了？" - 文件覆盖问题
❌ "这版本怎么跑不动了？" - 环境不一致问题
❌ "小明改了我的代码！" - 协作冲突问题
❌ "最终版本到底是哪个？" - 版本混乱问题
❌ "能恢复上周的代码吗？" - 历史追溯问题

1.2 Git登场：版本控制的革命（500字）

理论说明：

Git是什么？分布式版本控制系统
谁创造了Git？（Linus Torvalds，2005年）
Git的核心特性：本地仓库、去中心化、强大的分支管理

核心理念讲解：

"快照而非差异"：Git保存每次提交的完整快照
"几乎所有操作都是本地执行"：离线也能工作
"数据完整性"：使用SHA-1哈希确保数据完整性

1.3 为什么比赛团队必须使用Git？（600字）

团队协作价值：

分工明确：每人负责不同模块，互不干扰
版本管理：每个阶段都有清晰的版本标记
回溯能力：任何时候都能恢复到之前的版本
代码审查：通过Merge Request检查队友的代码
备份保障：代码保存在远程服务器，不怕丢失

针对比赛场景：

省赛/国赛作品迭代：初赛→复赛→决赛，每阶段都有版本记录
团队分工：前端、后端、算法、文档，不同人在不同分支开发
代码审查：队长可以审核队员提交的代码，保证质量
紧急回退：出现问题时，快速回退到稳定版本

1.4 本章小结与学习目标（200字）

明确本章学习目标
引出下一章：理解Git的核心概念

📝 第二章：基础概念（2000字）

2.1 Git的三大工作区域（600字）

理论说明：三种状态的转换

工作区（Working Directory）
    ↓ git add
暂存区（Staging Area / Index）
    ↓ git commit
Git仓库（Git Repository）

详细解释：

工作区（Working Directory）
- 定义：项目在磁盘上的实际位置
- 特点：你可以在这里自由编辑文件
- 比喻：就像在一张白纸上画画
暂存区（Staging Area）
- 定义：Git的临时存储区域，保存下次提交的内容
- 特点：可以精确控制要提交的内容
- 比喻：就像画作的"草稿区"，决定哪些修改要正式保存
Git仓库（Repository）
- 定义：项目的历史记录数据库
- 特点：包含所有提交的记录和分支信息
- 位置：.git目录（隐藏目录）

2.2 文件的生命周期（500字）

文件状态图解：

未跟踪(Untracked) → 已跟踪(Tracked)
                      ↓
                已修改(Modified)
                      ↓ git add
                已暂存(Staged)
                      ↓ git commit
               已提交(Committed)

四种文件状态详解：

未跟踪（Untracked）
- 新创建的文件，还没有被Git管理
- git status显示为"Untracked files"
已修改（Modified）
- 已跟踪的文件被修改了
- 还没有放入暂存区
已暂存（Staged）
- 修改的文件已经添加到暂存区
- 等待下一次提交
已提交（Committed）
- 文件已经保存到本地仓库
- 形成一个历史快照

2.3 Git的对象模型（500字）

理论说明：Git如何存储数据

四种对象类型：

Blob对象：存储文件内容（每个文件就是一个blob）
Tree对象：存储目录结构（包含blob和tree的引用）
Commit对象：存储提交信息（包含tree和父commit的引用）
Tag对象：标记特定的commit

示例讲解：

# 假设我们有一个简单的Python项目
# project/
# ├── main.py
# └── utils.py

# Git会创建以下对象：
# 1. main.py -> blob对象
# 2. utils.py -> blob对象
# 3. project/目录 -> tree对象（包含两个blob的引用）
# 4. 第一次提交 -> commit对象（包含tree的引用）

为什么重要？

每个对象都有唯一的SHA-1哈希值
相同内容只存储一次（节省空间）
任何修改都可以追溯

2.4 远程仓库的概念（400字）

本地仓库 vs 远程仓库

概念	本地仓库	远程仓库
位置	你的电脑	服务器（GitHub/Gitee）
用途	日常开发和提交	团队共享和备份
操作	git commit	git push/pull
访问	无需网络	需要网络

常见的远程仓库服务：

GitHub：全球最大的代码托管平台
Gitee（码云）：国内访问速度快，推荐国内团队使用
GitLab：支持自建服务器，适合企业使用
Coding：腾讯云旗下，也有不错的口碑

2.5 本章小结（200字）

总结核心概念
预告下一章：开始实际使用Git

📝 第三章：实战入门（3000字）

3.1 安装与初始配置（400字）

安装Git

# Windows: 下载安装包
# 官网：https://git-scm.com/download/win

# 验证安装
git --version
# 输出示例：git version 2.40.0.windows.1

Python环境准备（如果你要用Python演示）

# 检查Python版本
python --version
# 确保有Python 3.6+

# 创建演示项目目录
mkdir git-tutorial
cd git-tutorial

初始配置

# 设置用户名和邮箱（必须）
git config --global user.name "你的名字"
git config --global user.email "your.email@example.com"

# 设置默认分支名为main（新版Git默认）
git config --global init.defaultBranch main

# 设置编辑器（可选）
git config --global core.editor "code --wait"  # VS Code

# 查看所有配置
git config --list

配置解释：

--global：全局配置，作用于当前用户所有项目
不加--global：仅作用于当前项目

3.2 初始化仓库（500字）

方法一：从头创建新仓库

# 创建项目目录
mkdir competition-project
cd competition-project

# 初始化Git仓库
git init
# 输出：Initialized empty Git repository in D:/projects/competition-project/.git/

# 查看隐藏目录
ls -la

方法二：克隆已有仓库

# 克隆远程仓库（队长分享的仓库）
git clone https://gitee.com/your-team/competition-project.git

# 指定文件夹名称
git clone https://gitee.com/your-team/competition-project.git my-project

# 克隆特定分支
git clone -b develop https://gitee.com/your-team/competition-project.git

初始化后的变化：

.
├── .git/          # Git仓库目录（隐藏）
├── .gitignore     # 忽略的文件（可选）
└── (你的项目文件)

3.3 创建Python演示项目（600字）

创建项目结构

# 创建演示用的Python项目
mkdir src
mkdir tests
mkdir docs

# 创建Python文件
# src/__init__.py
# src/main.py
# src/utils.py

Python代码示例：简单的数据处理模块

# src/data_processor.py
"""数据处理器模块 - 用于比赛项目的数据处理"""

from typing import List, Dict, Any
import json
from datetime import datetime


class DataProcessor:
    """数据处理器类"""

    def __init__(self, name: str = "default"):
        self.name = name
        self.data: List[Dict[str, Any]] = []
        self.processed_count = 0

    def load_data(self, filepath: str) -> bool:
        """加载数据文件"""
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                self.data = json.load(f)
            return True
        except FileNotFoundError:
            print(f"文件 {filepath} 未找到")
            return False
        except json.JSONDecodeError:
            print(f"文件 {filepath} 不是有效的JSON格式")
            return False

    def process(self) -> List[Dict[str, Any]]:
        """处理数据"""
        results = []
        for item in self.data:
            processed_item = {
                'timestamp': datetime.now().isoformat(),
                'original': item,
                'processed_value': self._calculate(item)
            }
            results.append(processed_item)
            self.processed_count += 1
        return results

    def _calculate(self, item: Dict) -> float:
        """计算逻辑（内部方法）"""
        return sum(item.get('values', [])) / len(item.get('values', [1]))

    def save_results(self, results: List, output_path: str) -> bool:
        """保存处理结果"""
        try:
            with open(output_path, 'w', encoding='utf-8') as f:
                json.dump(results, f, ensure_ascii=False, indent=2)
            return True
        except Exception as e:
            print(f"保存失败: {e}")
            return False


if __name__ == "__main__":
    processor = DataProcessor("比赛数据处理器")
    print(f"初始化 {processor.name}")

3.4 基本命令：add、commit、status（800字）

命令一：git status - 查看仓库状态

# 查看当前状态
git status
# 输出示例：
# On branch main
# No commits yet
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#   src/
#   tests/
#   docs/

# 简短格式
git status -s
# 输出示例：
# ?? src/
# ?? tests/
# ?? docs/
# ?? src/data_processor.py

状态符号解释：

?? = 未跟踪的文件（Untracked）
A  = 新添加到暂存区的文件（Added）
M  = 修改过的文件（Modified）
D  = 删除的文件（Deleted）
R  = 重命名的文件（Renamed）

命令二：git add - 添加到暂存区

# 添加单个文件
git add src/data_processor.py

# 添加整个目录
git add src/

# 添加所有文件（慎用！）
git add .

# 添加所有修改和删除，但不添加未跟踪的文件
git add -u

# 查看暂存区
git status
# 输出：
# Changes to be committed:
#   new file:   src/data_processor.py

添加演示：工作流程

# 创建新文件
echo "# 比赛项目" > README.md

# 查看状态（未跟踪）
git status -s
# 输出：?? README.md

# 添加到暂存区
git add README.md

# 查看状态（已暂存）
git status -s
# 输出：A  README.md

命令三：git commit - 提交到仓库

# 基本提交
git commit -m "feat: 添加数据处理模块"

# 同时提交已跟踪文件的修改
git add -u
git commit -m "fix: 修复数据处理逻辑"

# 简短提交（适合小改动）
git commit -m "docs: 更新README"

# 查看提交历史
git log

提交信息规范

<type>: <subject>

<body>

<footer>

type类型：

feat: 新功能（Feature）
fix: 修复bug
docs: 文档变更
style: 代码格式（不影响功能）
refactor: 重构（不是新功能或bug修复）
test: 测试相关
chore: 构建过程或辅助工具的变动

完整提交示例

git commit -m "feat: 添加数据处理器基础功能

- 实现DataProcessor类
- 支持JSON文件加载
- 实现基本的数据处理逻辑
- 添加错误处理机制

Closes #001"

3.5 查看历史记录（400字）

命令：git log - 查看提交历史

# 完整格式
git log

# 简洁格式（一行一个提交）
git log --oneline

# 图形化显示分支
git log --graph --oneline --all

# 显示最近3次提交
git log -3

# 显示文件变更统计
git log --stat

# 显示特定文件的变更
git log -- src/data_processor.py

git log 输出示例

commit a1b2c3d4e5f6g7h8i9j0
Author: 刘航宇 <3364451258@qq.com>
Date:   2026-04-23 10:30:00

    feat: 添加数据处理模块

commit x9y8z7w6v5u4t3s2r1q0
Author: 刘航宇 <3364451258@qq.com>
Date:   2026-04-23 09:15:00

    init: 初始化项目结构

命令：git diff - 查看变更

# 查看工作区的变更（未暂存）
git diff

# 查看暂存区的变更（已暂存）
git diff --staged

# 查看两个版本的差异
git diff HEAD~1 HEAD

# 查看特定文件的变更
git diff src/data_processor.py

git diff 输出示例

diff --git a/src/data_processor.py b/src/data_processor.py
index 1234567..89abcdef 100644
--- a/src/data_processor.py
+++ b/src/data_processor.py
@@ -10,6 +10,7 @@ class DataProcessor:
         self.data: List[Dict[str, Any]] = []
         self.processed_count = 0
+        self.created_at = datetime.now().isoformat()

3.6 .gitignore文件（300字）

作用：告诉Git忽略某些文件，不纳入版本控制

常见Python项目的.gitignore

# .gitignore

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg

# 虚拟环境
venv/
ENV/
env/
.venv/

# IDE
.vscode/
.idea/
*.swp
*.swo
*~

# 数据文件
*.csv
*.xlsx
*.json
!config.json  # 例外：保留config.json

# 日志
*.log

# 系统文件
.DS_Store
Thumbs.db

创建.gitignore

# 方法一：手动创建
touch .gitignore
code .gitignore

# 方法二：从模板复制
# GitHub提供了各种语言的.gitignore模板
# https://github.com/github/gitignore

3.7 本章小结（200字）

总结本章学习的命令
强调练习的重要性
引出下一章：分支管理

📝 第四章：分支管理（3500字）

4.1 为什么需要分支？（500字）

理论说明：什么是分支？

主分支（main）
    │
    ├── 分支A（feature-1）
    │       └── 完成开发
    │
    ├── 分支B（feature-2）
    │       └── 开发中...
    │
    └── 继续开发

没有分支的问题：

❌ 所有人在同一个代码线上开发
❌ 新功能还没完成，不能提交代码
❌ 提交的代码相互影响
❌ 很难找到稳定可用的版本

使用分支的优势：

✅ 每人可以在自己的分支上开发
✅ 不影响其他人的工作
✅ 可以随时切换到稳定版本
✅ 可以并行开发多个功能
✅ 出问题可以快速回退

4.2 分支相关命令（800字）

查看分支

# 查看本地分支
git branch

# 查看所有分支（包括远程）
git branch -a

# 查看分支详细信息
git branch -v

# 查看已合并/未合并到当前分支的分支
git branch --merged
git branch --no-merged

创建分支

# 创建新分支（但不切换）
git branch feature/data-processor

# 创建并切换到新分支（推荐）
git checkout -b feature/data-processor

# 新版Git推荐使用switch
git switch -c feature/data-processor  # 创建并切换
git switch feature/data-processor     # 仅切换

切换分支

# 切换到已有分支
git checkout feature/data-processor

# 新版Git
git switch feature/data-processor

# 切换回主分支
git checkout main
git switch main

重命名分支

# 重命名当前分支
git branch -m old-name new-name

# 重命名其他分支
git branch -m feature-old feature-new

删除分支

# 删除已合并的分支（安全删除）
git branch -d feature/completed

# 强制删除分支（即使未合并）
git branch -D feature/discard

# 删除远程分支
git push origin --delete feature/old

4.3 分支操作实战演示（1000字）

场景：三人团队开发比赛项目

团队成员：

小明：队长，负责main和develop分支
小红：开发"数据处理"功能
小刚：开发"界面展示"功能

Step 1：队长初始化仓库

# 队长：创建仓库
mkdir competition-project
cd competition-project
git init

# 创建主开发分支
git checkout -b develop

# 创建初始文件
echo "# 比赛项目" > README.md
git add .
git commit -m "init: 创建项目基础结构"

# 推送到远程
git remote add origin https://gitee.com/team/competition-project.git
git push -u origin main
git push -u origin develop

Step 2：队员克隆仓库

# 小红和小刚：克隆仓库
git clone https://gitee.com/team/competition-project.git
cd competition-project

# 切换到develop分支
git checkout develop

Step 3：队员创建自己的功能分支

# 小红：创建数据处理分支
git checkout -b feature/data-processor

# 小刚：创建界面分支
git checkout -b feature/ui-display

Step 4：各自开发并提交

# 小红：在feature/data-processor分支
# 创建src/data_processor.py
git add .
git commit -m "feat: 添加数据处理模块"

# 小刚：在feature/ui-display分支
# 创建src/ui.py
git add .
git commit -m "feat: 添加界面模块"

Step 5：队长查看分支状态

# 查看所有分支
git branch -a

# 输出示例：
#   feature/data-processor    # 小红的分支
#   feature/ui-display       # 小刚的分支
# * develop                  # 当前分支
#   main                     # 主分支
#   remotes/origin/develop   # 远程develop
#   remotes/origin/main      # 远程main

4.4 合并分支（800字）

命令：git merge - 合并分支

Fast-forward合并（快速合并）

适用场景：目标分支没有新的提交

# 假设当前在develop分支
# feature分支有新的提交

# 执行合并
git checkout develop
git merge feature/data-processor

# 输出：
# Updating a1b2c3d..e4f5g6h
# Fast-forward
#  src/data_processor.py | 50 +++++++++++++++++++++++++++
#  1 file changed, 50 insertions(+)

Three-way合并（三方合并）

适用场景：目标分支也有新的提交

# develop分支有新提交
# feature分支有新提交

# 执行合并
git checkout develop
git merge feature/ui-display

# 输出：
# Merge made by the 'recursive' strategy.
#  src/ui.py | 30 ++++++++++++++++++
#  1 file changed, 30 insertions(+)

解决冲突后合并

# 如果有冲突，Git会提示
# CONFLICT (content): Merge conflict in src/utils.py
# Automatic merge failed; fix conflicts and then commit

# 手动解决冲突后
git add src/utils.py
git commit -m "merge: 合并feature分支，解决冲突"

4.5 Rebase：变基操作（600字）

概念解释：将当前分支的修改"移植"到另一个分支的顶部

为什么使用rebase？

Before rebase:
main:     A---B---C
              \
feature:       D---E

After rebase:
main:     A---B---C
                  \
feature:           D'---E'

命令：git rebase

# 将feature分支变基到main分支
git checkout feature/data-processor
git rebase main

# 如果有冲突，解决后继续
git rebase --continue

# 或者放弃rebase
git rebase --abort

merge vs rebase 对比

特性	merge	rebase
是否保留历史	✅ 保留完整历史	❌ 历史更线性
是否产生新提交	✅ 产生merge commit	❌ 不产生额外commit
冲突解决	可能需要多次	每个提交逐一解决
适用场景	公共分支合并	本地分支整理

何时使用？

✅ merge：合并到main/develop等主分支
✅ rebase：整理本地未推送的提交
❌ rebase：不要rebase已经推送的公共分支！

4.6 分支命名规范（300字）

推荐命名规范

# 功能分支
feature/<功能描述>
feature/data-processor
feature/user-authentication
feature/image-recognition

# 修复分支
bugfix/<问题描述>
bugfix/fix-login-error
bugfix/memory-leak

# 发布分支
release/<版本号>
release/v1.0.0
release/v2.1.0

# 热修复分支
hotfix/<问题描述>
hotfix/critical-security-patch

# 个人分支（可选）
<姓名>/<描述>
liuhangyu/feature-1
xiaohong/feature-2

命名原则：

使用小写字母和连字符（-）
简洁明了，看名称就知道是什么
包含关联的issue/ticket编号（如果有）

4.7 本章小结（200字）

总结分支管理的核心命令
强调分支命名规范的重要性
引出下一章：团队协作流程

📝 第五章：团队协作流程（4000字）

5.1 Git Flow工作流介绍（600字）

什么是Git Flow？

一套成熟的分支管理模型，适合中大型团队项目管理

分支类型：

长期分支：
├── main/master     # 生产环境，始终保持稳定
└── develop         # 开发主分支，集成所有功能

短期分支：
├── feature/*       # 功能分支
├── release/*      # 发布分支
└── hotfix/*       # 热修复分支

开发流程图

develop ←─────────────────────────────────┐
  │                                      │
  ├── feature/A ───────────────────┐      │
  │                               ↓      │
  │                              合并     │
  │                                      │
  ├── feature/B ──────────────┐  │      │
  │                            ↓  │      │
  │                           合并 │      │
  │                            │  │      │
  ├── feature/C ───────────┐    │  │      │
  │                        ↓    │  │      │
  │                       合并  │  │      │
  │                        │    │  │      │
  └────────────────────────┼────┴──┴─────┘
                            ↓
                       测试完成
                            ↓
                      release/v1.0
                            ↓
                        发布上线
                            ↓
                         main

5.2 Pull Request / Merge Request（800字）

概念解释

Pull Request（PR）/ Merge Request（MR）：

申请将自己的分支合并到目标分支
代码审查的载体
团队协作的核心流程

工作流程

1. 从develop创建功能分支
2. 开发并提交代码
3. 推送分支到远程仓库
4. 创建Pull Request
5. 队长/队友审查代码
6. 讨论并修改（如有需要）
7. 合并到develop分支

GitHub/Gitee创建PR示例

# Pull Request 标题
feat: 添加数据处理模块

# Pull Request 内容
## 功能描述
实现了DataProcessor类，支持JSON数据的加载和处理。

## 改动内容
- 新增DataProcessor类
- 实现load_data()方法
- 实现process()方法
- 添加错误处理

## 测试情况
- [x] 单元测试通过
- [x] 手动测试通过

## 截图（如有）

## 相关Issue
Closes #001

5.3 代码审查基础（700字）

为什么需要代码审查？

好处：
✅ 发现bug和潜在问题
✅ 保证代码质量
✅ 知识共享和团队学习
✅ 统一代码风格
✅ 减少代码知识孤岛

代码审查检查清单

## 代码审查清单

### 功能正确性
- [ ] 代码逻辑是否正确？
- [ ] 是否处理了边界情况？
- [ ] 是否有单元测试？

### 代码质量
- [ ] 命名是否清晰？
- [ ] 是否有重复代码？
- [ ] 是否遵循项目的代码规范？

### 性能
- [ ] 是否有性能问题？
- [ ] 是否有内存泄漏？
- [ ] 算法复杂度是否合理？

### 安全性
- [ ] 是否有安全漏洞？
- [ ] 是否正确处理用户输入？
- [ ] 是否泄露敏感信息？

### 可维护性
- [ ] 代码是否易于理解？
- [ ] 是否有适当的注释？
- [ ] 文档是否更新？

审查示例：发现的问题

# ❌ 审查前：代码存在问题
def process_user_data(data):
    result = data['name'] + data['age']  # 字符串拼接数字会报错
    file = open('output.txt', 'w')
    file.write(result)
    # 文件没有关闭，可能导致资源泄漏
    return result

# ✅ 审查后：修复后的问题
def process_user_data(data: dict) -> str:
    """处理用户数据"""
    try:
        name = data.get('name', '')
        age = data.get('age', 0)
        # 正确处理类型转换
        result = f"{name} - Age: {age}"

        # 使用with语句确保文件关闭
        with open('output.txt', 'w', encoding='utf-8') as file:
            file.write(result)

        return result
    except KeyError as e:
        print(f"缺少必要字段: {e}")
        raise ValueError("Invalid data format")

5.4 团队协作实战：完整的开发流程（1000字）

场景：三人团队开发"智能数据分析系统"

团队分工：

小明（队长）：项目负责人，负责develop分支和代码审查
小红：开发"数据采集"模块
小刚：开发"数据展示"模块

Day 1：项目初始化

# 小明：初始化项目
mkdir smart-data-analysis
cd smart-data-analysis
git init
git checkout -b develop

# 创建项目基础结构
mkdir -p src/{data_collection,data_analysis,visualization}
mkdir -p tests docs

# 创建基础文件
echo "# 智能数据分析系统" > README.md
echo "python\n__pycache__/" > .gitignore

# 初始提交
git add .
git commit -m "init: 创建项目基础结构"
git remote add origin https://gitee.com/team/smart-data-analysis.git
git push -u origin develop

# 分享仓库给队友
# （通过Gitee/GitHub的团队设置）

Day 2-3：小红开发数据采集模块

# 小红：克隆仓库
git clone https://gitee.com/team/smart-data-analysis.git
cd smart-data-analysis

# 切换到develop，拉取最新代码
git checkout develop
git pull origin develop

# 创建功能分支
git checkout -b feature/data-collection

# 开发数据采集模块
# src/data_collection/collector.py

cat > src/data_collection/collector.py << 'EOF'
"""数据采集器模块"""
import requests
from typing import List, Dict
import time


class DataCollector:
    """数据采集器"""

    def __init__(self, base_url: str):
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            'User-Agent': 'SmartDataAnalysis/1.0'
        })

    def fetch_data(self, endpoint: str, params: dict = None) -> List[Dict]:
        """从API获取数据"""
        url = f"{self.base_url}/{endpoint}"
        response = self.session.get(url, params=params, timeout=30)
        response.raise_for_status()
        return response.json()

    def collect_with_retry(self, endpoint: str, max_retries: int = 3) -> List[Dict]:
        """带重试机制的数据采集"""
        for attempt in range(max_retries):
            try:
                return self.fetch_data(endpoint)
            except requests.RequestException as e:
                if attempt == max_retries - 1:
                    raise
                wait_time = 2 ** attempt  # 指数退避
                time.sleep(wait_time)
                print(f"重试 {attempt + 1}/{max_retries}...")
EOF

# 提交代码
git add src/data_collection/
git commit -m "feat: 添加DataCollector类，支持API数据采集

- 实现基础的fetch_data方法
- 添加请求超时和错误处理
- 实现带重试机制的采集方法

Closes #001"

# 推送到远程
git push origin feature/data-collection

Day 2-3：小刚开发数据展示模块

# 小刚：克隆仓库
git clone https://gitee.com/team/smart-data-analysis.git
cd smart-data-analysis

# 创建自己的功能分支
git checkout develop
git checkout -b feature/data-visualization

# 开发可视化模块
cat > src/visualization/chart_generator.py << 'EOF'
"""图表生成器模块"""
import matplotlib.pyplot as plt
from typing import List, Dict, Optional
import matplotlib
matplotlib.use('Agg')  # 非交互式后端


class ChartGenerator:
    """图表生成器"""

    def __init__(self, style: str = 'seaborn'):
        try:
            plt.style.use(style)
        except:
            plt.style.use('default')

    def plot_line_chart(self, data: List[float], labels: List[str],
                       title: str, output_path: str) -> bool:
        """绘制折线图"""
        try:
            plt.figure(figsize=(10, 6))
            plt.plot(labels, data, marker='o')
            plt.title(title)
            plt.xlabel('X轴')
            plt.ylabel('Y轴')
            plt.grid(True, alpha=0.3)
            plt.savefig(output_path, dpi=300, bbox_inches='tight')
            plt.close()
            return True
        except Exception as e:
            print(f"绘图失败: {e}")
            return False

    def plot_bar_chart(self, categories: List[str], values: List[float],
                       title: str, output_path: str) -> bool:
        """绘制柱状图"""
        try:
            plt.figure(figsize=(10, 6))
            plt.bar(categories, values, color='skyblue')
            plt.title(title)
            plt.xlabel('类别')
            plt.ylabel('数值')
            plt.xticks(rotation=45)
            plt.tight_layout()
            plt.savefig(output_path, dpi=300, bbox_inches='tight')
            plt.close()
            return True
        except Exception as e:
            print(f"绘图失败: {e}")
            return False
EOF

# 提交代码
git add src/visualization/
git commit -m "feat: 添加ChartGenerator类，支持图表生成

- 实现折线图绘制功能
- 实现柱状图绘制功能
- 添加错误处理机制

Closes #002"

git push origin feature/data-visualization

Day 4：创建Pull Request

# 小红：创建Pull Request
# 在GitHub/Gitee网页端操作
# 选择 feature/data-collection -> develop

# Pull Request内容模板：
"""
## 功能描述
实现了DataCollector类，支持从API采集数据。

## 主要功能
- [x] fetch_data：基础数据获取
- [x] collect_with_retry：带重试的数据采集
- [x] 超时和错误处理

## 测试情况
```bash
pytest tests/test_collector.py -v

所有测试通过 ✓

代码审查

遵循PEP8规范
有适当的文档字符串
有单元测试 """

小刚：创建Pull Request（类似）


**Day 5：代码审查与合并**

```powershell
# 小明（队长）：审查队友的代码

# 查看Pull Request的改动
git fetch origin
git log origin/feature/data-collection --stat

# 在本地测试队友的代码
git checkout -b review/data-collection origin/feature/data-collection
pytest tests/test_collector.py -v

# 如果有问题，在PR下评论指出
# 如果没问题，合并代码

# 合并小红的分支
git checkout develop
git merge origin/feature/data-collection
git push origin develop

# 合并小刚的分支
git merge origin/feature/data-visualization
git push origin develop

# 删除已合并的分支
git branch -d feature/data-collection
git branch -d feature/data-visualization
git push origin --delete feature/data-collection
git push origin --delete feature/data-visualization

5.5 版本标签管理（500字）

命令：git tag - 标记重要版本

# 创建轻量标签
git tag v1.0.0

# 创建附注标签（推荐，包含更多信息）
git tag -a v1.0.0 -m "版本1.0.0：完成基础功能开发"

# 查看所有标签
git tag

# 查看标签详情
git show v1.0.0

# 给历史提交打标签
git tag -a v0.9.0 <commit-hash> -m "版本0.9.0：初始发布"

# 推送标签到远程
git push origin v1.0.0

# 推送所有标签
git push origin --tags

# 删除标签
git tag -d v0.9.0              # 本地
git push origin --delete v0.9.0 # 远程

版本号规范（语义化版本）

主版本.次版本.修订号
v1.2.3

含义：
- 1：主版本号（不兼容的重大更新）
- 2：次版本号（新增功能，向后兼容）
- 3：修订号（bug修复，向后兼容）

比赛项目标签示例

# 初赛提交版本
git tag -a v0.1.0-dev -m "初赛提交版本"
git push origin v0.1.0-dev

# 省赛晋级版本
git tag -a v1.0.0-provincial -m "省赛提交版本"
git push origin v1.0.0-provincial

# 国赛最终版本
git tag -a v2.0.0-final -m "国赛最终提交版本"
git push origin v2.0.0-final

5.6 本章小结（200字）

总结团队协作的完整流程
强调代码审查的重要性
引出下一章：冲突处理

📝 第六章：冲突处理（2500字）

6.1 什么是冲突？（400字）

理论说明：冲突产生的原因

场景：小明和小红同时修改了文件的同一行

小明的工作：
  文件第10行：result = a + b
              ↓ 修改为
              result = a + b + c

小红的工作（同一时间）：
  文件第10行：result = a + b
              ↓ 修改为
              result = a * b

Git无法自动决定：保留谁的修改？
→ 产生冲突，需要手动解决

什么时候会产生冲突？

✅ 多人同时修改了同一文件的同一行
✅ 一个人删除文件，另一个人修改了它
✅ 多人修改了同一个分支的名字

什么时候不会冲突？

✅ 修改了不同文件
✅ 修改了同一文件的不同部分
✅ 修改了同一文件但不同行

6.2 识别冲突标记（400字）

冲突标记格式

<<<<<<< HEAD
    # 当前分支的代码
    result = a + b + c
=======
    # 合并进来的分支的代码
    result = a * b
>>>>>>> feature-branch

完整冲突示例

# src/data_processor.py

def calculate(data):
    # ... 省略其他代码 ...

<<<<<<< HEAD
    # 队长的修改：添加日志
    print(f"开始计算，数据长度: {len(data)}")
    result = sum(data)
=======
    # 小红的修改：添加错误处理
    if not data:
        return 0
    result = sum(data)
>>>>>>> feature/data-processor

    # ... 其他代码 ...

<<<<<<< HEAD
    print(f"计算完成，结果: {result}")
=======
    return result
>>>>>>> feature/data-processor

查看冲突文件

# 查看有冲突的文件
git status
# 输出：
# both modified:   src/data_processor.py

# 查看冲突列表
git diff --name-only --diff-filter=U

6.3 解决冲突的方法（800字）

方法一：手动编辑解决

# 1. 拉取最新代码，产生冲突
git pull origin develop

# 输出：
# Auto-merging src/data_processor.py
# CONFLICT (content): Merge conflict in src/data_processor.py

# 2. 打开冲突文件
code src/data_processor.py

# 3. 手动编辑，删除冲突标记，决定保留哪些代码
# 删除 <<<<<<< HEAD, =======, >>>>>>> feature-branch 这些行

# 4. 解决后的代码
def calculate(data):
    # ... 省略其他代码 ...

    # 队长的日志
    print(f"开始计算，数据长度: {len(data)}")

    # 小红的错误处理
    if not data:
        return 0
    result = sum(data)

    # 队长的日志
    print(f"计算完成，结果: {result}")
    return result

# 5. 添加并提交
git add src/data_processor.py
git commit -m "merge: 解决与feature/data-processor的冲突

保留队长的日志功能和小红的错误处理"

方法二：使用合并工具

# 配置合并工具（以VS Code为例）
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd "code --wait $MERGED"

# 启动合并工具
git mergetool

# 使用VS Code的图形界面解决冲突

方法三：接受某一方的版本

# 接受当前分支（HEAD）的版本
git checkout --ours src/data_processor.py

# 接受合并进来的分支的版本
git checkout --theirs src/data_processor.py

# 然后添加并提交
git add src/data_processor.py
git commit -m "merge: 采用对方的版本解决冲突"

6.4 避免冲突的最佳实践（500字）

策略一：频繁拉取和推送

# 每天开始工作前
git pull origin develop

# 完成工作后尽快推送
git push origin feature/your-feature

策略二：功能分支要小而专注

# ❌ 不好：一个分支做太多事情，容易产生冲突
git checkout -b feature/big-feature

# ✅ 好：一个分支只做一件事
git checkout -b feature/add-login
git checkout -b feature/add-search
git checkout -b feature/add-export

策略三：及时与队友沟通

# 团队沟通示例

小明：@小红 我要修改 data_processor.py 的第50-60行
小红：好的，我这边暂时不动那个文件
小明：好的，完成了

# 或者
小明：@小红 我改完了，你那边rebase一下我的分支
小红：好的，rebase完成，没有冲突

策略四：使用锁机制（对于重要文件）

# 在README.md中添加锁标记（自定义流程）
# README.md
<!-- FILE LOCK: 小明正在编辑 2024-01-15 -->

策略五：制定代码规范

# 约定好代码风格，减少格式冲突
# .editorconfig

root = true

[*]
charset = utf-8
indent_style = space
indent_size = 4

6.5 冲突解决后的检查清单（200字）

## 冲突解决后检查清单

- [ ] 删除了所有冲突标记（<<<<<<<, =======, >>>>>>>）
- [ ] 代码逻辑正确，没有错误
- [ ] 本地测试通过
- [ ] 提交信息说明了解决方式
- [ ] 其他队员知道冲突已解决

6.6 本章小结（200字）

总结冲突产生的原因和解决方法
强调预防冲突比解决冲突更重要
引出下一章：比赛场景实战

📝 第七章：比赛场景实战（3000字）

7.1 比赛项目特点分析（400字）

比赛项目的特殊需求

特点：
1. 时间紧迫：通常只有几周准备时间
2. 团队临时：队员可能来自不同专业
3. 迭代快速：初赛→复赛→决赛，快速迭代
4. 文档重要：技术文档、演示视频、答辩PPT
5. 成果展示：需要打包、部署、演示

Git在比赛中的价值

✅ 多人并行开发，互不干扰
✅ 版本管理，清楚记录每个阶段
✅ 代码审查，保证代码质量
✅ 快速回退，出问题能及时恢复
✅ 文档统一管理，不分散
✅ 备份保障，代码不会丢失

7.2 三人团队协作范例（1200字）

项目背景

项目：智能垃圾分类系统
比赛：中国大学生计算机设计大赛
时间：4周（初赛→复赛）
团队：小明（队长）、小红、小刚

团队分工

角色	姓名	职责	分支
队长	小明	项目架构、算法、代码审查	develop
队员A	小红	前端界面开发	feature/frontend
队员B	小刚	后端API、数据库	feature/backend

Week 1：项目初始化

# 小明：创建项目仓库
mkdir smart-waste-classification
cd smart-waste-classification
git init
git checkout -b develop

# 创建项目结构
mkdir -p src/{models,utils,api}
mkdir -p frontend
mkdir -p docs
mkdir -p tests

# 创建基础文件
echo "# 智能垃圾分类系统" > README.md
echo "比赛：中国大学生计算机设计大赛" >> README.md
echo "团队：XXX" >> README.md

# 创建.gitignore
echo "python\n__pycache__/" > .gitignore
echo "venv/" >> .gitignore
echo "*.pth" >> .gitignore"
echo "data/" >> .gitignore"
echo "models/*.pth" >> .gitignore"

# 初始提交
git add .
git commit -m "init: 创建项目基础结构

- 创建目录结构
- 添加.gitignore
- 添加基础README"

# 推送到远程
git remote add origin https://gitee.com/team/smart-waste-classification.git
git push -u origin develop

Week 1-2：队员开始开发

# 小红：克隆并创建前端分支
git clone https://gitee.com/team/smart-waste-classification.git
cd smart-waste-classification
git checkout develop
git checkout -b feature/frontend

# 小红：开发前端界面
# frontend/index.html
# frontend/style.css
# frontend/app.js

git add frontend/
git commit -m "feat: 完成前端界面基础布局

- 添加HTML结构
- 添加基础样式
- 实现图片上传功能

Closes #001"

git push origin feature/frontend

# 小刚：创建后端分支
git checkout develop
git checkout -b feature/backend

# 小刚：开发后端API
# src/api/classifier.py

cat > src/api/classifier.py << 'EOF'
"""图像分类API"""
from fastapi import FastAPI, UploadFile, File
from fastapi.middleware.cors import CORSMiddleware
import torch
from torchvision import transforms
from PIL import Image
import io

app = FastAPI(title="垃圾分类API")

# CORS配置
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# 加载模型（简化版）
class Classifier:
    def __init__(self):
        self.model = None
        self.categories = ['其他垃圾', '厨余垃圾', '可回收垃圾', '有害垃圾']

    def load_model(self, model_path: str):
        """加载训练好的模型"""
        self.model = torch.load(model_path)
        self.model.eval()

    async def predict(self, image_data: bytes) -> dict:
        """预测图片类别"""
        # 图片预处理
        image = Image.open(io.BytesIO(image_data))
        transform = transforms.Compose([
            transforms.Resize((224, 224)),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406],
                               std=[0.229, 0.224, 0.225])
        ])
        img_tensor = transform(image).unsqueeze(0)

        # 预测
        with torch.no_grad():
            outputs = self.model(img_tensor)
            _, predicted = torch.max(outputs, 1)
            category = self.categories[predicted.item()]

        return {
            "category": category,
            "confidence": float(torch.softmax(outputs, dim=1)[0][predicted])
        }

classifier = Classifier()

@app.post("/predict")
async def predict_image(file: UploadFile = File(...)):
    """垃圾分类预测接口"""
    contents = await file.read()
    result = await classifier.predict(contents)
    return result
EOF

git add src/api/
git commit -m "feat: 添加FastAPI垃圾分类接口

- 实现/predict端点
- 支持图片上传
- 添加CORS支持

Closes #002"

git push origin feature/backend

Week 2：代码审查与合并

# 小明：审查并合并小红的代码
git fetch origin
git checkout -b review/frontend origin/feature/frontend

# 本地测试
pip install -r requirements.txt
# ... 测试代码 ...

# 合并到develop
git checkout develop
git merge origin/feature/frontend
git push origin develop

# 同样审查合并小刚的代码
git checkout develop
git merge origin/feature/backend
git push origin develop

# 删除功能分支
git branch -d feature/frontend
git branch -d feature/backend
git push origin --delete feature/frontend
git push origin --delete feature/backend

Week 3：省赛提交版本

# 小明：创建提交标签
git checkout develop

# 确保所有代码已合并
git status

# 创建省赛提交版本
git tag -a v1.0.0-provincial -m "省赛提交版本 v1.0.0

功能：
- 基础图像分类功能
- RESTful API接口
- 简单的前端界面

技术栈：
- PyTorch深度学习模型
- FastAPI后端框架
- HTML/CSS前端

团队：小明、小红、小刚"

# 推送标签
git push origin v1.0.0-provincial

# 导出代码（用于提交）
git archive -o submission-provincial.zip --prefix=project/ HEAD

Week 4：决赛优化

# 如果晋级，继续开发

# 创建决赛分支
git checkout -b release/final
git checkout -b feature/improve-accuracy
git checkout -b feature/add-export

# ... 开发新功能 ...

# 决赛提交
git tag -a v2.0.0-final -m "决赛最终版本 v2.0.0

新增功能：
- 模型精度提升至92%
- 数据导出功能
- 用户反馈系统

性能优化：
- API响应时间减少50%
- 前端加载速度提升"

git push origin v2.0.0-final

7.3 文档管理（500字）

比赛文档的重要性

比赛通常需要提交：
1. 技术文档 - 详细说明系统架构、技术实现
2. 使用说明 - 如何安装、运行、使用系统
3. 演示视频 - 展示系统功能
4. 答辩PPT - 比赛答辩用

Git管理文档的最佳实践

# 创建文档分支
git checkout -b docs

# 创建文档目录
mkdir -p docs/技术文档
mkdir -p docs/使用手册
mkdir -p docs/答辩PPT

# 技术文档示例
cat > docs/技术文档/系统设计.md << 'EOF'
# 智能垃圾分类系统 - 系统设计

## 1. 系统架构

### 1.1 整体架构
系统采用前后端分离架构...

### 1.2 技术选型
- 前端：HTML5 + CSS3 + JavaScript
- 后端：FastAPI + PyTorch
- 数据库：SQLite
- 部署：Docker
EOF

# 文档单独提交
git add docs/
git commit -m "docs: 添加技术文档

- 系统架构说明
- 技术选型介绍
- API接口文档"

git push origin docs

7.4 代码备份策略（400字）

多层备份策略

第一层：本地仓库
    - .git目录包含所有历史
    - 定期git commit保存进度

第二层：远程仓库
    - 推送到GitHub/Gitee
    - 即使电脑损坏也不丢

第三层：重要版本标签
    - 每个关键节点打标签
    - 可以快速回溯

第四层：定期导出
    - 重要时间点导出压缩包
    - 额外备份到网盘

备份命令

# 定期推送到远程（每天至少一次）
git push origin develop

# 推送所有分支和标签
git push origin --all
git push origin --tags

# 导出重要版本
git archive -o backup-v1.0.0.zip --prefix=project/ v1.0.0-provincial

# 检查远程仓库状态
git remote -v
git fetch --all

7.5 本章小结（200字）

总结比赛场景的实践方法
强调团队沟通和文档的重要性
引出下一章：实用技巧

📝 第八章：实用技巧（2000字）

8.1 Git配置优化（300字）

别名配置

# 使用简短的别名
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.unstage 'reset HEAD --'

# 高级别名（带参数）
git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

# 查看所有别名
git config --get-regexp alias

使用示例

# 配置前
git status
git checkout develop
git commit -m "..."

# 配置后
git st
git co develop
git ci -m "..."

8.2 忽略已被跟踪的文件（300字）

问题：文件已提交后，想添加到.gitignore但不生效

解决方法

# 1. 添加到.gitignore
echo "config.py" >> .gitignore

# 2. 从Git缓存中移除（不再跟踪）
git rm --cached config.py

# 3. 提交更改
git add .gitignore
git commit -m "chore: 移除config.py的跟踪"

# 如果想保留本地文件但停止跟踪
git rm --cached config.py

8.3 修改最后一次提交（300字）

补充漏提交的文件

# 漏提交了一个文件
git commit -m "feat: 添加数据处理模块"
# 发现漏了 tests/test_processor.py

# 补充提交（不创建新提交）
git add tests/test_processor.py
git commit --amend --no-edit

# 注意：会修改commit的hash值

修改提交信息

# 修改最后一次提交的信息
git commit --amend -m "新的提交信息"

8.4 暂存工作区（400字）

场景：正在开发新功能，突然要切换分支处理紧急问题

命令：git stash - 暂存当前工作

# 1. 暂存当前修改（不提交）
git stash
# 输出：Saved working directory and index state WIP on feature/xxx

# 2. 切换到其他分支处理问题
git checkout develop
# ... 处理紧急问题 ...
git checkout feature/xxx

# 3. 恢复暂存的工作
git stash pop
# 输出：Dropped refs/stacking...

# 查看暂存列表
git stash list
# 输出：
# stash@{0}: WIP on feature/xxx: abc1234 feat: 添加功能A
# stash@{1}: WIP on feature/yyy: def5678 feat: 添加功能B

# 应用特定暂存
git stash apply stash@{1}

# 清除暂存
git stash drop stash@{0}

高级用法

# 暂存包括未跟踪的文件
git stash -u

# 暂存已忽略的文件
git stash -a

# 创建一个新分支并应用暂存
git stash branch new-branch-name

# 查看暂存的diff
git stash show -p

8.5 查找问题commit（300字）

命令：git bisect - 二分查找问题

# 1. 开始二分查找
git bisect start

# 2. 标记已知有问题的版本
git bisect bad

# 3. 标记正常的版本
git bisect good v1.0.0

# Git会自动checkout中间的版本
# 测试该版本是否有问题

# 4. 标记结果
git bisect good  # 如果没问题
git bisect bad   # 如果有问题

# 5. Git继续查找，直到找到问题commit
# 输出：xxx is first bad commit

# 6. 结束查找
git bisect reset

8.6 重写历史（200字）

警告：不要重写已推送的提交历史！

# 修改最后一个commit（还没push）
git commit --amend

# 变基整理多个commit
git rebase -i HEAD~3

# 交互式变基选项：
# pick = 保留该commit
# squash = 将该commit合并到上一个
# reword = 修改commit信息
# drop = 删除该commit

8.7 清理仓库（200字）

# 删除已合并到main的分支
git branch --merged main | grep -v "main" | xargs git branch -d

# 清理无用的远程跟踪分支
git fetch --prune

# 清理未跟踪的文件（干净的工作区）
git clean -f      # 删除未跟踪的文件
git clean -fd     # 删除未跟踪的文件和目录
git clean -n      # 预览（不实际删除）

# 完整清理
git clean -fdx

8.8 本章小结（200字）

总结实用的Git技巧
强调安全使用重写历史等命令
引出最后一章：总结与进阶

📝 第九章：总结（1500字）

9.1 核心概念回顾（400字）

必须掌握的核心命令

# 基础操作
git init              # 初始化仓库
git clone             # 克隆仓库
git add               # 添加到暂存区
git commit            # 提交到仓库
git status            # 查看状态
git log               # 查看历史

# 分支操作
git branch            # 查看/创建分支
git checkout/-switch  # 切换分支
git merge            # 合并分支
git rebase           # 变基

# 远程操作
git remote            # 管理远程仓库
git push              # 推送到远程
git pull              # 拉取并合并
git fetch             # 仅拉取

# 高级操作
git stash             # 暂存工作
git cherry-pick       # 选择性合并
git bisect            # 二分查找问题

9.2 团队协作最佳实践（500字）

给队长的建议

✅ 建立清晰的分支管理策略（Git Flow）
✅ 制定代码规范和提交流程
✅ 认真审查队友的Pull Request
✅ 保持develop分支的稳定
✅ 及时合并和清理已完成的分支
✅ 重要版本及时打标签
✅ 定期推送代码，不要等到最后一刻

给队员的建议

✅ 从develop分支创建功能分支
✅ 功能完成后及时创建Pull Request
✅ 提交信息要清晰明了
✅ 定期拉取最新代码，减少冲突
✅ 保持分支小而专注
✅ 积极与队友沟通，避免重复劳动
✅ 遇到冲突不要慌，先理解再解决

9.3 学习路线建议（300字）

初级阶段（第1-2周）

学习目标：掌握基础操作
- git init, clone, add, commit
- git status, log, diff
- 创建和使用分支
- 基本的合并操作

推荐资源：
- Pro Git（免费在线书）
- Git官方文档

中级阶段（第3-4周）

学习目标：掌握团队协作
- Git Flow工作流
- Pull Request流程
- 解决合并冲突
- 标签管理

推荐资源：
- GitHub官方教程
- Atlassian Git教程

高级阶段（持续学习）

学习目标：熟练运用
- git bisect, cherry-pick
- 变基操作的高级用法
- 子模块管理
- Git钩子
- 自定义Git配置

推荐资源：
- 官方文档深入阅读
- 参与开源项目学习

9.4 常见问题速查表（300字）

问题	解决方案
误删了文件怎么恢复？	`git checkout -- file` 或 `git restore file`
想撤销上一次的提交？	`git revert HEAD` 或 `git reset HEAD~1`
文件误加入暂存区？	`git reset HEAD file`
想查看某个文件的修改历史？	`git log -p -- file`
两个分支冲突了怎么办？	手动编辑解决，`git add` 后 `git commit`
忘记了commit的信息？	`git log` 查看，或 `git commit --amend`
想临时保存当前修改？	`git stash`
误操作导致丢失代码？	`git reflog` 找回

9.5 结语（200字）

恭喜你完成了《Git团队协作指南》的学习！

现在你掌握了：

Git的核心概念和基本操作
分支管理的技巧
团队协作的流程
冲突处理的方法
比赛项目的实践案例

记住：实践是最好的老师。不要害怕犯错，Git给了你足够的"后悔药"。现在开始使用Git管理你的比赛项目吧！

祝你取得好成绩！🏆

📎 附录：命令速查表（1000字）

A.1 基础命令速查

# 创建和初始化
git init                          # 初始化新仓库
git clone <url>                   # 克隆远程仓库
git clone <url> <folder-name>     # 克隆到指定文件夹

# 查看信息
git status                        # 查看工作区状态
git status -s                     # 简洁格式
git log                           # 查看提交历史
git log --oneline                 # 简洁一行格式
git log --graph                   # 图形化显示分支
git diff                          # 查看未暂存的变更
git diff --staged                 # 查看已暂存的变更
git show <commit>                 # 查看特定提交

# 基础操作
git add <file>                    # 添加文件到暂存区
git add .                          # 添加所有变更
git commit -m "message"           # 提交
git commit -am "message"           # 暂存并提交已跟踪文件

# 撤销操作
git checkout -- <file>            # 丢弃工作区修改
git reset HEAD <file>             # 取消暂存
git revert <commit>               # 创建新提交撤销指定提交
git reset --soft HEAD~1           # 撤销上次提交，保留修改
git reset --hard HEAD~1           # 撤销上次提交，丢弃修改

A.2 分支命令速查

# 查看分支
git branch                        # 查看本地分支
git branch -a                     # 查看所有分支
git branch -v                     # 查看分支详情
git branch -d <branch>           # 删除已合并的分支
git branch -D <branch>           # 强制删除分支

# 创建和切换
git checkout <branch>             # 切换分支
git checkout -b <new-branch>     # 创建并切换
git switch <branch>               # 切换（新版）
git switch -c <new-branch>       # 创建并切换（新版）

# 合并
git merge <branch>                # 合并分支到当前分支
git merge --no-ff <branch>        # 禁用快速合并
git rebase <branch>              # 变基到目标分支
git rebase -i HEAD~3             # 交互式变基

# 标签
git tag                           # 查看标签
git tag <version>                 # 创建轻量标签
git tag -a <version> -m "msg"     # 创建附注标签
git tag -a <version> <commit>     # 给历史提交打标签
git push origin <tag>             # 推送标签
git push origin --tags            # 推送所有标签

A.3 远程操作速查

# 远程仓库
git remote -v                     # 查看远程仓库
git remote add origin <url>      # 添加远程仓库
git remote remove origin         # 移除远程仓库

# 拉取和推送
git fetch                         # 拉取远程更新（不合并）
git pull                          # 拉取并合并
git push                          # 推送到远程
git push -u origin <branch>      # 首次推送，设置上游分支
git push origin --delete <branch> # 删除远程分支

A.4 高级命令速查

# 暂存
git stash                         # 暂存当前工作
git stash list                    # 查看暂存列表
git stash pop                     # 恢复并删除暂存
git stash apply                   # 恢复暂存（保留）
git stash drop                    # 删除暂存

# 查找问题
git bisect start                 # 开始二分查找
git bisect bad                    # 标记有问题
git bisect good <commit>          # 标记没问题
git bisect reset                 # 结束查找

# 杂项
git cherry-pick <commit>         # 选择性合并提交
git reflog                       # 查看操作历史
git clean -f                     # 删除未跟踪文件
git clean -n                     # 预览删除（不实际删除）

📚 参考资源

官方文档

Pro Git（中文版）：https://git-scm.com/book/zh/v2
Git官方文档：https://git-scm.com/docs

在线学习

GitHub Skills：https://skills.github.com/
Atlassian Git教程：https://www.atlassian.com/git/tutorials
Learn Git Branching：https://learngitbranching.js.org/

工具推荐

GUI工具：SourceTree、GitKraken、VS Code Git插件
终端：Windows Terminal + Git Bash
托管平台：GitHub（国际）、Gitee（国内）

🎯 大纲总结

本大纲设计了24000字级别的技术博客，包含：

理论说明（30%）：概念讲解、原理说明、为什么这样做
命令讲解（30%）：详细的命令语法、参数说明、使用场景
实操演示（40%）：完整的代码示例、真实场景模拟、步骤演示

每个章节都包含：

✅ 详细的知识点讲解
✅ 可运行的Python代码示例
✅ PowerShell/Git命令演示
✅ 比赛场景的实际应用
✅ 最佳实践和建议

请确认大纲是否符合您的需求？

确认后我将按照此大纲开始撰写完整文章。

59 KiB Raw Permalink Blame History Unescape Escape