跳到主内容
Zhimalab
7 天快速入门 · 互动教程
0%
🎓 大友互动教程

Git 快速入门
7 天互动教程

从零开始,通过终端实操、图解和测验,7 天掌握 Git 版本控制的核心技能。适合大二学生及编程初学者。

7
天课程
35+
命令实操
21
测验题目
1
终端模拟器

Day 1版本控制与 Git

版本控制系统(VCS)是软件开发中不可或缺的工具,它记录文件的每一次变更,让你随时可以回溯历史、协作开发、并行实验。Git 是目前最流行的分布式版本控制系统。

集中式 vs 分布式

集中式 (SVN) 中央服务器 A B C 分布式 (Git) 远程仓库 完整仓库A 完整仓库B 完整仓库C 每个开发者都有完整仓库副本 离线也能提交、查看历史、创建分支
集中式依赖中央服务器;分布式每人都有完整仓库,远程仓库仅用于协作同步

安装与首次配置

安装 Git 后,第一件事是设置你的身份信息——每次提交都会记录这些信息:

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

--global 表示全局配置,只需设置一次。项目级配置用 --local(默认),仅对当前仓库生效。

?知识检测
1Git 属于哪种类型的版本控制系统?
集中式版本控制系统
分布式版本控制系统
本地版本控制系统
云端版本控制系统
2git config --global user.name "名字" 的作用是什么?
创建一个新仓库
设置全局提交者用户名
创建新分支
设置远程仓库地址
3以下哪个不是 Git 的核心优势?
支持离线操作
分支创建成本低廉
必须持续联网才能提交
完整的版本历史保存在本地

Day 2本地仓库核心操作

本地仓库是 Git 的基础。今天学习创建仓库、追踪文件、提交变更——这是 Git 最核心的工作流程。

创建仓库

  mkdir my-project && cd my-project
git init
  

git init 会在当前目录创建一个 .git 隐藏文件夹,它就是 Git 仓库的核心——存储所有版本数据。此后该目录成为一个 Git 仓库。

追踪与提交

工作区 Working Directory 你正在编辑的文件 git add 暂存 暂存区 Staging Area 准备提交的快照 git commit 提交 版本库 Repository 永久历史记录
Git 核心工作流:工作区 → git add → 暂存区 → git commit → 版本库
  touch README.md                     # 创建文件
git add README.md                    # 添加到暂存区
git commit -m "Add README"          # 提交到版本库
git status                           # 查看当前状态
git log --oneline                    # 查看提交历史
  

git add 是「拍快照」——把文件当前状态放入暂存区。git commit 是「盖章存档」——把暂存区的快照永久写入版本库。两步分离让你可以精确控制每次提交包含哪些变更。

动手实践:第一次提交

在下方终端中依次执行以下命令(点击命令可复制到终端):

  1. git init — 初始化仓库
  2. touch hello.txt — 创建文件
  3. git status — 查看状态(hello.txt 是 Untracked)
  4. git add hello.txt — 暂存文件
  5. git status — 再次查看(变为 staged)
  6. git commit -m "Add hello.txt" — 提交
  7. git log --oneline — 查看历史
?知识检测
1git add 命令的作用是什么?
提交文件到版本库
将文件从工作区添加到暂存区
推送代码到远程
创建新分支
2git commit -m "msg" 中 -m 参数的作用?
修改上一次提交
指定提交信息的作者
直接在命令行中指定提交信息
合并多个提交
3如何查看仓库的提交历史?
git history
git log
git show
git list
4.git 目录的作用是什么?
存放项目源码
Git 仓库的核心数据(版本库)
存放编译产物
存放依赖包

Day 3三个区域与差异比较

深入理解工作区、暂存区、版本库三个区域,学会用 git diff 查看差异——这是 Git 进阶的关键。

文件的生命周期

Untracked Staged Committed Modified git add git commit 编辑文件 git add 编辑后
文件在 Untracked → Staged → Committed → Modified → Staged 之间循环

git diff 三种用法

  git diff              # 工作区 vs 暂存区(还没 add 的改动)
git diff --staged     # 暂存区 vs 版本库(已 add 还没 commit 的改动)
git diff HEAD         # 工作区 vs 版本库(所有未提交的改动)
  

git diff 的输出格式:@@ -旧行,行数 +新行,行数 @@ 标记差异位置,绿色 + 是新增行,红色 - 是删除行。

动手实践:观察差异

先完成 Day 2 的练习,然后继续:

  1. echo "Hello Git" > hello.txt — 修改文件内容
  2. git diff — 查看工作区改动
  3. git add hello.txt — 暂存
  4. git diff --staged — 查看已暂存改动
  5. echo "Line 2" >> hello.txt — 再次修改
  6. git status — 注意:同时有 staged 和 unstaged 改动
  7. git add hello.txt — 重新暂存最新内容
  8. git commit -m "Update hello.txt" — 提交
?知识检测
1git diff(不带参数)比较的是什么?
工作区 vs 版本库
暂存区 vs 版本库
工作区 vs 暂存区
两个分支之间
2文件从暂存区进入版本库用什么命令?
git add
git commit
git push
git save
3为什么 Git 设计了暂存区(而不是直接提交)?
为了减缓提交速度
让你精确控制每次提交包含哪些变更
为了占用更多磁盘
防止文件丢失
4git diff --staged 显示什么?
工作区与暂存区的差异
暂存区与版本库的差异
两个提交之间的差异
远程与本地的差异

Day 4分支管理

分支是 Git 最强大的特性——它让你可以并行开发不同功能而互不干扰。掌握分支是团队协作的基础。

什么是分支

分支本质上是一个指向某次提交的可移动指针。创建分支几乎零成本——只是创建了一个新指针,不复制任何文件。

创建分支并提交 C1 C2 C3 C4 main → 分叉点 main feature git checkout -b feature → 新提交 C4
从 C3 创建 feature 分支,feature 上有了新提交 C4,main 仍指向 C3

核心命令

  git branch                    # 查看所有分支
git branch feature            # 创建分支(不切换)
git switch feature            # 切换到分支(推荐)
git checkout feature          # 切换分支(旧写法)
git switch -c feature         # 创建并切换(推荐)
git checkout -b feature       # 创建并切换(旧写法)
git merge feature             # 将 feature 合并到当前分支
git branch -d feature         # 删除已合并的分支
  

合并:快进 vs 三方

Fast-forward(快进) C1 C2 C3 main→ 合并前 main 在 C2 feature C1 C2 C3 main + feature → 指针直接前移,无新提交 三方合并 C2 C3 C4 main→ feature→ C3 C4 M main→ merge commit M 两条分支各有新提交 创建合并提交,有两个父提交
快进合并:直接移动指针;三方合并:创建新提交合并两条分支线

合并冲突:当两条分支修改了同一文件的同一区域时,Git 无法自动合并,会提示冲突。你需要手动编辑文件解决冲突(保留需要的部分),然后 git add + git commit

动手实践:分支操作
  1. git branch — 查看当前分支
  2. git branch feature — 创建分支
  3. git switch feature — 切换到 feature
  4. touch feature.txt — 创建新文件
  5. git add feature.txt — 暂存
  6. git commit -m "Add feature.txt" — 提交
  7. git switch main — 切回主分支
  8. git merge feature — 合并
  9. git log --oneline — 查看历史
?知识检测
1创建新分支但不切换到该分支的命令?
git switch -c feature
git branch feature
git checkout feature
git merge feature
2什么是"快进合并"(Fast-forward)?
合并速度很快
当前分支没有新提交,直接移动指针到目标分支
合并时产生冲突需要快速解决
两个分支完全相同
3合并冲突时应该怎么做?
删除冲突文件
手动编辑冲突文件,保留正确内容后 add + commit
放弃合并,使用 git reset --hard
重新 clone 仓库
4git switch 和 git checkout 的关系?
完全不同的命令
switch 是 checkout 的子功能,只负责切换分支
checkout 是 switch 的别名
没有关系

Day 5远程仓库与协作

远程仓库让你和团队共享代码。学习 clone、push、pull、fetch,掌握 GitHub 协作工作流。

本地与远程

本地仓库 工作区 + 暂存区 + 版本库 + 本地分支 远程仓库 GitHub / GitLab / Gitee 远程分支 + 团队代码 git push 推送本地提交 git pull / fetch 拉取远程更新
push 推送本地变更到远程;pull/fetch 拉取远程更新到本地

核心命令

  git clone <url>                    # 克隆远程仓库到本地
git remote add origin <url>        # 关联远程仓库
git remote -v                       # 查看远程仓库
git push origin main                # 推送本地分支到远程
git push -u origin main             # 首次推送并设置跟踪
git pull origin main                # 拉取并合并 (= fetch + merge)
git fetch origin                    # 仅拉取,不自动合并
git push                            # 已设置跟踪时简写
  

fetch vs pullgit fetch 只下载远程更新但不修改本地分支,安全且可控;git pull = fetch + merge,直接合并到当前分支。建议初学者用 fetch + 手动 merge,更可控。

GitHub 协作工作流

  1. Fork — 在 GitHub 上 Fork 项目到自己的账号
  2. Clonegit clone 你的 Fork 到本地
  3. Branchgit switch -c fix-bug 创建功能分支
  4. Commit — 修改代码,git add + git commit
  5. Pushgit push origin fix-bug 推送到你的 Fork
  6. PR — 在 GitHub 上发起 Pull Request 请求合并
  7. Review & Merge — 代码审查通过后合并
动手实践:远程操作

本终端模拟了远程仓库,可以练习推送和拉取:

  1. git remote add origin https://github.com/me/repo.git — 添加远程
  2. git remote -v — 查看远程
  3. git push -u origin main — 推送并设置跟踪
  4. git pull origin main — 拉取(模拟)
  5. git fetch origin — 仅获取
?知识检测
1git clone 的作用是什么?
推送本地代码到远程
克隆远程仓库到本地
创建本地仓库副本
删除远程仓库
2git fetch 和 git pull 的区别?
没有区别
fetch 只下载不合并,pull = fetch + merge
fetch 推送,pull 拉取
pull 只下载不合并
3git push -u origin main 中的 -u 是什么意思?
强制推送
设置上游跟踪关系,之后可直接 git push
推送所有分支
撤销推送
4GitHub 上发起 Pull Request 的前提是什么?
你是仓库 owner
你有一个分支推送到远程(通常是你 fork 的仓库)
仓库必须是 public
你必须有 write 权限

Day 6撤销与回退

每个人都会犯错——Git 提供了多种撤销方式。关键是理解每种命令撤销的是什么、影响范围多大。

三种撤销场景

git reset 三种模式对比 版本库 (HEAD) — 暂存区 — 工作区 --soft 仅回退 HEAD --mixed (默认) 回退 HEAD + 暂存区 --hard 全部回退(危险!) ■ 被回退 □ 保留 git revert <commit> 创建新提交来"反做"指定提交 ✓ 安全,不改写历史,适合公共分支 git checkout -- <file> 丢弃工作区的未暂存修改 ⚠ 不可恢复!还原到暂存区状态
reset 移动指针(改写历史);revert 创建反向提交(保留历史)

git stash:临时存放

当你在分支 A 工作到一半,需要切换到分支 B 修复 bug,但 A 的改动还没完成不想提交——git stash 把工作区改动"藏"起来,工作区恢复干净。修完 bug 后 git stash pop 取回。

  git stash               # 暂存当前工作区改动
git stash list          # 查看暂存列表
git stash pop           # 取出最近一次暂存(并删除栈)
git stash apply         # 取出但不删除(可指定 stash@{1})
git stash drop          # 删除指定暂存
  

git reset --hardgit checkout -- <file>永久丢弃未提交的改动,无法恢复!使用前务必确认。如果误删,git reflog 可能帮你找回(但仅限已提交的)。

动手实践:撤销操作
  1. echo "wrong" > hello.txt — 修改文件
  2. git checkout -- hello.txt — 撤销工作区修改
  3. echo "staged" > temp.txt — 创建新文件
  4. git add temp.txt — 暂存
  5. git reset HEAD temp.txt — 取消暂存
  6. echo "wip" > work.txt — 创建工作文件
  7. git add work.txt — 暂存
  8. git stash — 暂存工作
  9. git stash pop — 取回
  10. git log --oneline — 查看历史
?知识检测
1git reset --hard 的作用是什么?
只移动 HEAD 指针
移动 HEAD 并重置暂存区
彻底回退:移动 HEAD + 重置暂存区 + 丢弃工作区改动
撤销最后一次提交但保留改动
2git revert 和 git reset 的核心区别?
没有区别
revert 创建新提交来撤销,reset 移动指针改写历史
revert 更快
reset 更安全
3git stash 的作用是什么?
删除文件
临时保存工作区改动,恢复干净的工作区
永久存储文件
创建备份分支
4git checkout -- <file> 的效果?
暂存文件
提交文件
将文件恢复到暂存区/HEAD的状态,丢弃工作区修改
删除文件

Day 7进阶与最佳实践

最后一天学习 rebase、tag、.gitignore 和提交规范——这些技能让你从"会用 Git"升级到"用好 Git"。

git rebase:变基

rebase 将你的分支提交"搬到"另一个分支的最新提交之上,保持线性历史。与 merge 的区别:

merge(保留分支历史) C1 C2 C4 C3 M 有合并提交 M,历史有分叉 rebase(线性历史) C1 C2 C4 C3 C3' C5' C3 被"搬"到 C4 之后变成 C3' 线性历史,无合并提交 ⚠ 改写了提交历史,勿用于公共分支
merge 保留完整分支历史;rebase 重写提交使其线性

git tag:版本标记

  git tag v1.0.0                  # 轻量标签
git tag -a v1.0.0 -m "Release"  # 附注标签(推荐)
git tag                         # 列出所有标签
git push origin v1.0.0          # 推送单个标签
git push --tags                 # 推送所有标签
  

.gitignore:忽略文件

编译产物、依赖包、IDE 配置等不应纳入版本控制。创建 .gitignore 文件指定忽略规则:

  # 依赖
node_modules/
vendor/

# 编译产物
dist/
build/
*.o
*.class

# IDE
.idea/
.vscode/
*.swp

# 系统
.DS_Store
Thumbs.db

# 环境变量
.env
.env.local
  

提交信息规范(Conventional Commits):type(scope): description,如 feat(auth): add login pagefix(api): handle null responsedocs: update README。类型包括 feat / fix / docs / style / refactor / test / chore。

动手实践:进阶操作
  1. git tag -a v1.0 -m "First release" — 创建标签
  2. git tag — 查看标签
  3. touch .gitignore — 创建忽略文件
  4. echo "node_modules/" > .gitignore — 写入规则
  5. git add .gitignore — 暂存
  6. git commit -m "chore: add .gitignore" — 提交
  7. git log --oneline — 查看完整历史
?知识检测
1git rebase 的作用是什么?
合并分支
将当前分支的提交"搬到"目标分支最新提交之上,保持线性历史
删除提交
创建标签
2.gitignore 文件的作用?
记录 Git 配置
指定不需要 Git 追踪的文件和目录
存储密码
记录提交日志
3Conventional Commits 中 "feat(auth): add login" 的含义?
修复了 auth 的 login bug
auth 模块新增了登录功能
auth 模块的文档更新
auth 模块重构了登录
4git tag -a v1.0 -m "Release" 创建的是什么类型的标签?
轻量标签
附注标签(annotated)
远程标签
临时标签

📋 命令速查表

日常开发中最常用的 Git 命令,按功能分类。输入关键词可筛选。

配置

git config --global user.name "名字"
设置全局用户名
git config --global user.email "邮箱"
设置全局邮箱
git config --list
查看所有配置
git config --global init.defaultBranch main
设置默认分支名

创建仓库

git init
在当前目录初始化 Git 仓库
git clone <url>
克隆远程仓库到本地
git clone <url> <dir>
克隆到指定目录

基础操作

git add <file>
将文件添加到暂存区
git add .
添加所有变更到暂存区
git commit -m "msg"
提交暂存区到版本库
git commit -am "msg"
add + commit(仅对已追踪文件)
git status
查看工作区状态
git status -s
简洁模式状态
git log
查看提交历史
git log --oneline --graph
图形化简洁历史
git diff
查看工作区与暂存区差异
git diff --staged
查看暂存区与版本库差异
git show <hash>
查看某次提交的详情

分支

git branch
列出所有本地分支
git branch <name>
创建新分支
git branch -a
列出所有分支(含远程)
git branch -d <name>
删除已合并分支
git switch <name>
切换分支
git switch -c <name>
创建并切换分支
git checkout <name>
切换分支(旧写法)
git checkout -b <name>
创建并切换(旧写法)
git merge <name>
将指定分支合并到当前分支

远程

git remote -v
查看远程仓库
git remote add <name> <url>
添加远程仓库
git remote remove <name>
移除远程仓库
git fetch <remote>
拉取远程更新(不合并)
git pull <remote> <branch>
拉取并合并
git push <remote> <branch>
推送本地分支到远程
git push -u origin main
首次推送并设置跟踪

撤销

git checkout -- <file>
丢弃工作区修改
git reset HEAD <file>
取消暂存(不丢失改动)
git reset --soft HEAD~1
撤销上次提交,保留改动在暂存区
git reset --mixed HEAD~1
撤销提交和暂存,保留工作区
git reset --hard HEAD~1
彻底撤销(危险!丢弃所有改动)
git revert <hash>
创建反向提交撤销指定提交(安全)
git stash
临时保存工作区改动
git stash list
查看暂存列表
git stash pop
取回最近一次暂存
git clean -fd
删除未追踪的文件和目录

标签

git tag
列出所有标签
git tag <name>
创建轻量标签
git tag -a <name> -m "msg"
创建附注标签(推荐)
git push origin <tag>
推送单个标签
git push --tags
推送所有标签

进阶

git rebase <branch>
将当前分支变基到目标分支
git rebase -i HEAD~3
交互式变基最近3个提交
git cherry-pick <hash>
将指定提交应用到当前分支
git reflog
查看 HEAD 移动历史(找回误删提交)
git bisect
二分查找引入 bug 的提交
git blame <file>
查看文件每行的最后修改者
🎓

恭喜完成!

Git 快速入门 · 7 天互动教程
0/21
测验总分

你已经掌握了 Git 的核心概念和操作。继续在实践中积累经验,探索更多高级功能吧!

⚡ Git 终端模拟器