Git的渐进式教学

Git通用教程

零、最快的上手仅需要四步

#0.先拉取云端代码
git clone http://localhost:3000/所属组织/项目名.git

#1.将当前目录下的所有修改添加到暂存区
git add . 

#2.将暂存区中的修改提交到本地仓库，并填写本次提交说明
git commit -m "提交信息"

#3.
# 第一次提交使用以下命令绑定云端的main分支（咱们的工作分支）：
git push -u origin main # -u: 设置上游分支，绑定本地分支与远程分支的追踪关系
                        # origin: 远程仓库的默认别名（执行 git clone 时自动把origin和远程仓库连接绑定好了已经，可用git remote -v查看） 
                        
# 之后的提交使用以下命令提交就可以了（因为已经绑定过了）：
git push

一、Git基础配置

# 首次使用Git需要配置用户信息
git config --global user.email "you@example.com"
git config --global user.name "Your Name"

# 本地项目初始化为Git仓库，自行创建需要，云端拉取项目代码时，一般就不需要初始化了
git init

二、Git的四个工作区域

Git有4个工作区域，理解它们是掌握Git的关键：

工作区(编辑的文件) 
|   git add .
|-> 暂存区(待提交) 
    |   git commit -m "提交信息"
    |-> 本地仓库(提交历史) 
         |   git push origin 分支名
         |-> 远程仓库(云端备份)
区域 说明 位置
工作区 你编辑的文件目录 你的文件夹
暂存区 即将被提交的修改 .git/index
本地仓库 已提交的历史记录 .git/objects
远程仓库 云端备份 GitHub/GitLab

三、基本工作流程

完整流程示例

# 1. 编辑文件
echo "hello" > test.txt

# 2. 查看状态（未跟踪）
git status
# Untracked files: test.txt
# 会显示以下几种情况之一：
   # 1. 工作区状态
   Changes not staged for commit:
      modified: file1.txt    # 已修改但未暂存
   # 2. 暂存区状态
   Changes to be committed:
      new file: file2.txt    # 已暂存，等待提交
   # 3. 未跟踪状态
   Untracked files:
      file3.txt              # 工作区新文件，未被Git追踪

# 3. 暂存文件
git add test.txt     # 暂存指定文件
git add .            # 暂存所有修改

# 4. 提交到本地仓库
git commit -m "添加test.txt"

# 5. 推送到远程main仓库
git push origin main
git push             # 已绑定分支时可直接使用

# 查看提交历史 --一行一条记录的简洁格式
git log --oneline

四、分支操作与HEAD指针

4.1 HEAD指针概念

HEAD是Git中的指针，指向当前所在位置。

正常状态：
HEAD → 当前分支的最新提交

例如在main分支：
HEAD → main的最新提交
  • HEAD = 在仓库n多版本中你当前的位置（当前指针）
  • 分支名 = 该分支最新提交的标签

4.2 分支操作

# 查看所有分支
git branch

# 创建新分支
git branch 分支名

# 切换分支（移动HEAD指针）
git checkout 分支名
# HEAD → 新分支 → 该分支的最新提交

# 创建并切换分支（推荐）
git checkout -b 分支名
# 相当于：git branch 分支名 + git checkout 分支名

# 合并分支
git checkout main          # 切换到目标分支
git merge 分支名           # 合并指定分支到当前分支

# 删除分支
git branch -d 分支名

4.3 HEAD指针的应用

# HEAD相对引用
HEAD^      # 上一个提交
HEAD^^     # 上上个提交
HEAD~3     # 第3个祖先提交

# 实际应用
# git checkout HEAD^: 把 HEAD 移动到上一个提交 ，同时尝试让 暂存区和工作区都与上一个提交一致 。
git checkout HEAD^

五、撤销和回退操作

5.1 撤销修改

# 撤销工作区修改（丢弃未暂存的修改）
git restore 文件名
git restore .            # 撤销所有修改

# 取消暂存（文件回到工作区，保留修改）
git restore --staged 文件名
git restore --staged .   # 取消所有暂存

5.2 回退提交

# 回退到上一个版本，硬重置到上一个提交（工作区、暂存区、本地仓库全部重置，未提交修改将丢失）
git reset --hard HEAD^

# git reset --mixed HEAD^: 混合重置到上一个提交（默认模式，重置暂存区，工作区保留修改）
git reset --mixed HEAD^

# 回退提交，但保留修改在暂存区，软重置到上一个提交（仅移动HEAD指针，暂存区和工作区不变）
git reset --soft HEAD^

# 回退到指定版本
git reset --hard 版本号   # 先用 git log --oneline 查看

5.3 查看差异

# 工作区 vs 暂存区（未暂存的修改）
git diff

# 暂存区 vs 本地仓库（准备提交的修改）
git diff --staged

# 工作区 vs 本地仓库（所有修改）
git diff HEAD

六、拉取和合并

6.1 拉取更新

# 拉取并合并到工作区
git pull origin 分支名
git pull                # 已绑定分支时

# 只拉取到本地仓库（不合并）
git fetch origin
git fetch --all         # 所有远程分支

6.2 fetch vs pull

命令 作用 影响
git fetch 只下载，不合并 只更新本地仓库
git pull 下载并合并 更新工作区+暂存区+本地仓库

git pull origin main可以分解为：

远程仓库
    │ git fetch origin # 1. 获取远程分支（不合并），是一个本地分支，指向远程分支的最新提交
    ↓
本地保存的 origin/main
    │ git log HEAD..origin/main # 2. 在这时可以选择查看差异，比较本地分支和远程分支，查看有哪些远程提交
    │ git merge origin/main # 3. 确认无误后，合并远程分支到本地分支
    ↓
更新当前本地分支（工作区和暂存区更新为合并后的结果） # 如果本地和远程各自有新提交，可能产生合并提交：
       C ───────┐
      /          \
A ── B            M
      \          /
       D ───────┘

七、解决冲突

当多人修改同一文件时产生冲突：

  1. 拉取代码时提示冲突
  2. 打开冲突文件，找到标记：
    <<<<<<< HEAD
你的修改
=======
别人的修改
>>>>>>> 分支名
  3. 手动修改，保留需要的内容
  4. 标记冲突已解决：
    git add 文件名
git commit -m "解决冲突"
git push

八、实用技巧

# 暂存当前工作
git stash               # 临时保存修改
   # 这里可以插入git pull origin main命令，拉取最新代码，不符合心意，再执行git stash pop命令，恢复暂存的工作
git stash pop           # 恢复暂存的工作

# 查看远程仓库地址
git remote -v

# 交互式暂存（选择部分修改）
git add -p
# 从暂存区中移除文件追踪（保留本地文件），常用于将已追踪的文件加入.gitignore后取消暂存区已存在的追踪
git rm --cached 文件名

# 清除未跟踪的文件
git clean -n            # 预览
git clean -fd           # 执行

九、三种主要工作流程

流程一：简单使用——拉取、修改、提交

适合个人开发，或者已经确定直接在当前分支工作的情况。

# 1. 切换到主分支
git checkout main
# 2. 从云端拉取最新代码，并合并到当前分支
git pull origin main
# 3. 修改代码并测试
--
# 4. 查看修改状态
git status
# 5. 查看准备提交的具体内容
git diff
# 6. 将修改放入暂存区
git add .
# 7. 再次检查暂存区内容
git diff --staged
# 8. 提交到本地仓库
git commit -m "说明本次修改"
# 9. 推送到云端
git push origin main

流程方向：

云端远程仓库 ──pull──> 本地main分支和工作区
工作区 ──add──> 暂存区 ──commit──> 本地仓库 ──push──> 云端远程仓库

流程二：使用stash和pop，预览后决定是否保留

适合当前有未提交修改，但需要先拉取云端代码的情况。git stash先保存当前修改，git stash pop再恢复修改。

# 1. 查看当前修改
git status
git diff
# 2. 临时保存当前修改，让工作区变干净
git stash push -m "暂存当前修改"
# 3. 拉取云端最新代码
git pull origin main
# 4. 恢复之前暂存的修改
# pop会恢复修改，并在恢复成功后删除对应的stash记录
git stash pop
# 5. 检查合并后的代码并进行测试
git status
git diff
# 6A. 如果满意，正常提交
git add .
git commit -m "说明本次修改"
git push origin main
# 6B. 如果不满意，撤销刚恢复到工作区的修改
# 注意：这会丢弃当前工作区中未提交的修改，请确认没有其他需要保留的内容
git restore .

更安全的预览方式是使用 apply，因为它不会删除stash记录：

git stash
git pull origin main
git stash apply
# 预览并测试，不满意时清理工作区
git restore .
# 确认满意后，再删除已经用过的stash记录
git stash list
git stash drop stash@{0}

如果 stash pop 或 stash apply 产生冲突，应先解决冲突；不需要这些修改时，可以使用 git restore . 放弃未提交的修改。

流程三：从云端主分支创建本地分支，审查后合并

适合团队协作。主分支只保持稳定代码，开发和审查在新分支中进行。

# 1. 切换到本地主分支
git checkout main
# 2. 拉取云端主分支最新代码
git pull origin main
# 3. 从最新的main创建并切换到本地开发分支
git checkout -b feature-xxx
# 4. 在feature-xxx分支中开发和测试
--
# 5. 查看修改并提交到本地仓库
git status
git add .
git diff --staged
git commit -m "添加功能xxx"
# 6. 将开发分支推送到云端
git push -u origin feature-xxx
# 7. 在代码托管平台发起合并请求，进行代码审查
# 审查通过后，也可以在本地执行以下合并操作：
# 8. 回到本地主分支，并再次同步云端main
git checkout main
git pull origin main
# 9. 将开发分支合并到本地main
git merge feature-xxx
# 10. 推送合并后的main到云端
git push origin main
# 11. 合并完成后删除本地开发分支（可选）
git branch -d feature-xxx

流程方向：

云端main ──pull──> 本地main
本地main ──checkout -b──> 本地feature-xxx
本地feature-xxx ──push──> 云端feature-xxx
云端feature-xxx ──审查/合并──> 云端main
本地feature-xxx ──merge──> 本地main ──push──> 云端main

三种流程的选择：

流程 适用场景 核心特点
流程一 简单个人开发 直接在当前分支完成拉取、提交和推送
流程二 有未提交修改，需要先同步代码 用stash临时保存，恢复后检查，不满意可以撤销
流程三 团队协作和代码审查 新建开发分支，审查通过后合并到main

十、注意事项

  • 提交前先 git pull 获取最新代码，减少冲突
  • 提交信息要简洁明了，说明做了什么
  • 不要提交敏感信息（密码、密钥等）
  • 定期推送代码到远程，避免代码丢失
  • 使用 git status 随时查看当前状态

Git核心概念详解

Git的四个工作区域

Git 有 4个工作区域，理解它们是掌握Git的关键：

区域概览图

正向流程（提交代码）：
================================================================================

工作区 ──git add──> 暂存区 ──git commit──> 本地仓库 ──git push──> 远程仓库
(Working)          (Stage)              (Local)               (Remote)

反向流程（撤销/拉取）：
================================================================================

远程仓库 ──git pull──> 工作区（拉取并合并）
   │
   ├──git fetch──> 本地仓库（只拉取不合并）
   └──git merge──> 工作区 + 暂存区

本地仓库 ──git reset --hard──> 工作区（完全重置）
   │
   ├──git reset --soft──> 暂存区（保留修改在暂存区）
   └──git restore──> 工作区（恢复文件）

暂存区 ──git restore --staged──> 工作区（取消暂存）

四个区域详解

区域 说明 状态 可见性 位置
工作区 你编辑的文件目录 已修改 可见 你的文件夹
暂存区 即将被提交的修改 已暂存 不可见 .git/index
本地仓库 已提交的历史记录 已提交 不可见 .git/objects
远程仓库 云端备份 已推送 可见 GitHub/GitLab

各区域含义

  1. 工作区（Working Directory）

    • 你看到的实际文件目录
    • 你编辑代码的地方
    • 未被Git追踪的文件在这里
    • 状态：已修改

  2. 暂存区（Staging Area）

    • 即将被提交的修改
    • 使用 git add 后文件进入这里
    • 也叫"索引"（Index）
    • 状态：已暂存

  3. 本地仓库（Local Repository）

    • 已提交的历史记录
    • 使用 git commit 后保存到这里
    • 包含所有提交历史
    • 状态：已提交

  4. 远程仓库（Remote Repository）

    • 云端备份
    • GitHub、GitLab等服务器上的仓库
    • 使用 git push 上传
    • 状态：已推送

区域间操作命令（精确流向）

正向操作（提交代码）：

起点 终点 命令 说明
工作区 暂存区 git add 文件名 暂存指定文件
工作区 暂存区 git add . 暂存所有修改
暂存区 本地仓库 git commit -m "信息" 提交到本地
本地仓库 远程仓库 git push origin 分支 推送到远程

反向操作（撤销/拉取）：

起点 终点 命令 说明
远程仓库 工作区 git pull 拉取并合并到工作区
远程仓库 本地仓库 git fetch 只拉取到本地仓库（不合并）
本地仓库 工作区 git restore 文件名 从本地仓库恢复文件
本地仓库 工作区 git reset --hard HEAD^ 完全重置到上一版本
本地仓库 暂存区 git reset --soft HEAD^ 回退提交，修改保留在暂存区
暂存区 工作区 git restore --staged 文件名 取消暂存

查看差异命令

# 工作区 vs 暂存区（查看未暂存的修改）
git diff

# 暂存区 vs 本地仓库（查看已暂存，准备提交的修改）
git diff --staged

# 工作区 vs 本地仓库（查看所有修改）
git diff HEAD

文件状态变化图

未跟踪 ──git add──> 已暂存 ──git commit──> 已提交 ──git push──> 已推送
    │                  │                      │                    │
    └── 编辑文件 ──> 已修改 ──git add──> 已暂存 ───────────────────┘

实际操作流程

# 1. 编辑文件（工作区）
echo "hello" > test.txt

# 2. 查看状态（未跟踪）
git status
# Untracked files: test.txt

# 3. 暂存文件（进入暂存区）
git add test.txt

# 4. 再次查看状态（已暂存）
git status
# Changes to be committed: new file: test.txt
   git status
   # 会显示：
   # 1. 工作区状态
   Changes not staged for commit:
      modified: file1.txt    # 已修改但未暂存
   # 2. 暂存区状态
   Changes to be committed:
      new file: file2.txt    # 已暂存，等待提交
   # 3. 未跟踪状态
   Untracked files:
      file3.txt              # 工作区新文件，未被Git追踪

# 5. 提交到本地仓库
git commit -m "添加test.txt"

# 6. 推送到远程仓库
git push origin main

核心理解

  • 工作区 = 你的文件夹（可见的文件）
  • 暂存区 = 准备提交的清单（不可见，存在.git中）
  • 本地仓库 = 你的提交历史（存在.git中）
  • 远程仓库 = 云端备份（GitHub等）

为什么要暂存区？

  • 可以选择性提交，不必一次性提交所有修改
  • 可以修改提交内容，在提交前再次检查

关键区别：

  • git pull = 拉取远程更新直接合并到工作区
  • git fetch = 只拉取到本地仓库，不合并到工作区
  • git restore --staged = 取消暂存，文件回到工作区（保留修改）
  • git restore = 从本地仓库恢复文件，丢弃工作区修改
posted @ 2026-07-31 11:52  嘉君  阅读(12)  评论(0)    收藏  举报