想象你在玩一款大型角色扮演游戏。每完成一段关键剧情,系统都会提示你:是否存档?你痛快地按下确认键,随后大胆地走进地图上任何一条陌生路线——打输了、走岔了、把稀有道具搞丢了,统统不怕,只要读档,就能回到那个安稳的存档点重新来过。这一刻,你手里握着的,是一台不折不扣的时间机器。 版本控制,就是为文档和代码配备的这台时间机器。它把每一次修改记录成一个“存档点”,标注时间与原因;想回头时一键读档;想尝试两种完全不同的写法时,还能分出平行世界,互不干扰。团队协作更是如此——几个人同时编写一份技术手册,就像几个玩家共享同一套存档系统:谁改了哪一段、为什么改、什么时候改的,全部留痕可查,再也没有“最终版v3_真最终.doc”这种文件地狱。 本文要讲的版本控制,正是技术文档规范化管理的“存档系统”。你会从基础概念出发,依次掌握核心操作、分支管理、团队协作、文档应用与最佳实践,彻底告别靠文件名和复制粘贴硬撑的日子。

岗位关联

掌握版本控制是技术文档工程师与 AI 从业者的基本功:学会用 Git 管理文档、追踪变更、安全回退,你的每份交付物都将变得可追溯、可协作、可复用——这也是现代团队协作的事实标准。

目录
  1. 可视化演示
  2. 版本控制基础
  3. 核心操作
  4. 分支管理
  5. 团队协作
  6. 文档应用
  7. 最佳实践
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

动态演示深入理解版本控制的核心机制,通过架构/数据/状态/性能四种模式展示关键概念与交互流程。

本节配有交互动效(进入视口后自动加载,约 3KB)。

深入理解版本控制:文档版本 文档版本控制基本概念与价值 Git管理文档的工作流程 核心机制可视化 深入理解版本控制整体架构与关键组件

版本控制基础

玩 RPG 时,你修改了一段剧情对话,半小时后故事线崩了,但你并不慌张——因为两个关键节点之前你存过档。存档点就是你抵御“时间之灾”的保险。版本控制正是把这种保险机制带进了文档与代码的世界:再也不需要靠“最终版_v7_真最终.doc”这类文件名来苟延残喘,每一次值得纪念的状态都被系统妥善保存。

版本控制的核心思想朴素而强大:任何以文本形态存在的资产——代码、Markdown 文档、配置文件——都可以被完整记录每一次变化。要理解它,只需抓住三个基础概念:工作区是你眼前正在编辑的文档;版本库是存放所有历史存档的仓库;提交(commit)则是一个带有说明文字的存档点,记录着“谁在什么时候为什么做了哪些修改”。

版本的本质不是“每改一版就整份拷贝”,而是“基线 + 变更之和”:

正如游戏存档不复制整张光盘、只记录“你走到哪、身上有什么”,文档版本控制也只记录差异,让每次保存既轻盈又完整——这就是它能支撑大型技术文档库长期演进的秘密。

vn=v0+∑i=1nΔi\displaystyle v_n = v_0 + \sum_{i=1}^{n} \Delta_i
这个公式说明:当前版本 = 初始版本 + 历次修改的累积。版本控制系统不需要保存每一份完整快照,只需记录每个增量 Δ,就能在任意时刻重建任何版本。
  1. v₀(基线版本)项目第一次存档时的完整内容,相当于游戏里那个“新手村存档”。
    v0=初始快照v_0 = \text{初始快照}
  2. Δᵢ(第 i 次变更)每次提交记录的具体修改,可能只是一行措辞,也可能是一整章内容。
    Δi=第 i 次提交引入的差异\Delta_i = \text{第 } i \text{ 次提交引入的差异}
  3. 求和符号 Σ(累积运算)把从第一次到当前的所有变更逐一叠加。
    ∑i=1nΔi=Δ1+Δ2+⋯+Δn\sum_{i=1}^{n} \Delta_i = \Delta_1 + \Delta_2 + \cdots + \Delta_n
  4. vₙ(当前版本)基线加上所有增量后的最新状态。
    vn=基线版本+累积变更v_n = \text{基线版本} + \text{累积变更}

核心操作

存档系统光有“存档”按钮还不够,你还得会存取、会同步。游戏里有本地存档、云存档,还有从云端拉回旧档的操作。Git 的核心操作正是这三板斧:提交把状态固化成本地存档,推送把存档上传到团队共用的云端,拉取则在开工前把别人的最新进度同步回本地。

一份文档从“正在编辑”到“团队可见”,要经过一条流水线。这条流水线可以被写成一个简洁的公式:

别忘了还有反向操作 git pull:开工前先把远程最新的存档拉取到本地,就像开始游戏前先同步云存档。否则你在自己的旧进度上埋头写半天,一推上去才发现和同事的修改撞了车。

工作区→git add暂存区→git commit版本库→git push远程仓库\displaystyle 工作区 \xrightarrow{\text{git add}} 暂存区 \xrightarrow{\text{git commit}} 版本库 \xrightarrow{\text{git push}} 远程仓库
这个公式描述了修改从“草稿”到“团队共享”的完整旅程。每一步都有明确职责,缺一不可。
  1. 工作区(workspace)你正在编辑器里敲打的文字,改动尚未被 Git 感知。
    工作区=当前文件的实际内容\text{工作区} = \text{当前文件的实际内容}
  2. git add(加入暂存区)告诉 Git“这几处改动我想存档”,相当于勾选要装入背包的物品。
    →git add\xrightarrow{\text{git add}}
  3. git commit(正式提交)生成一个不可变的存档点,并附上一句修改原因。
    暂存区→git commit版本库\text{暂存区} \xrightarrow{\text{git commit}} \text{版本库}
  4. git push(推送远程)把本地存档上传到远程仓库,团队成员才能看到。
    版本库→git push远程仓库\text{版本库} \xrightarrow{\text{git push}} \text{远程仓库}

分支管理

有些游戏允许你“多周目”探索:主线走 A 结局时,另存一个档,回头去试 B 路线的隐藏剧情。分支就是版本控制里“另存为平行世界”的能力——它让冒险变得毫无负担:新版用户手册想改成问答式结构?先开一个 feature/问答式手册 分支,改坏了也不影响主干分毫。

有了分支,自然就要面对合并。合并最怕的场面是:主线和分支同时修改了同一段话,到底听谁的?Git 用“三向合并”解决这个问题,它不只看两个版本,还要参考它们分叉前的共同祖先:

如果两边恰好改的是同一段内容,裁判发现“两边都声称自己是新的”,就会判定冲突,需要你手动裁决——就像两个玩家争抢同一个 NPC 时,GM 必须出面协调。这并非缺陷,而是防止悄悄覆盖别人劳动成果的安全机制。

M=A∪Δmain∪Δfeature\displaystyle M = A \cup \Delta_{\text{main}} \cup \Delta_{\text{feature}}
三向合并公式:合并结果 = 共同祖先 + 主线上的修改 + 分支上的修改。共同祖先是裁判,它知道“谁才是真正的新改动”。
  1. A(共同祖先)两个分支分叉前最后一次共同的提交,是合并的裁判基准。
    A=分叉点之前的共同版本A = \text{分叉点之前的共同版本}
  2. Δ\_main(主线修改)分叉之后,主线上新增的修改。
    Δmain=主线的增量\Delta_{\text{main}} = \text{主线的增量}
  3. Δ\_feature(分支修改)分叉之后,分支上新增的修改。
    Δfeature=分支的增量\Delta_{\text{feature}} = \text{分支的增量}
  4. ∪(并集运算)把两边各自的变化叠加起来,得到合并结果。
    A∪Δmain∪Δfeature=合并后的版本A \cup \Delta_{\text{main}} \cup \Delta_{\text{feature}} = \text{合并后的版本}

团队协作

多人合作写文档,就像一群玩家联机打副本:每个人都握着同一份任务说明,但如果各自的小地图不同步,团灭只是时间问题。版本控制为团队协作提供了一致的地图与时间线,让“并行”成为可能而不是灾难。

标准协作流程是一条固定的流水线:分支开发 → 提交评审 → 合并主干。每个人在自己的分支上写作,完成后发起评审请求(Merge Request),团队成员检查内容、提出意见,通过后才允许合并进主干。评审是质量闸门,而闸门是否健康,可以用一个简单的指标观察:

就像副本开怪前队长要确认每个人都理解机制,评审保证了“每个人对攻略的认知达成共识”。配合精确到行的权限模型——谁可以写主干、谁只能提交分支——文档资产就始终在可控轨道上运行。

R=NmergedNrequested×100%\displaystyle R = \frac{N_{\text{merged}}}{N_{\text{requested}}} \times 100\%
评审通过率 = 成功合并的请求数 ÷ 提交的评审请求总数。它像副本的通关率一样,直接反映团队的协作健康度。
  1. N\_requested(提交的评审请求总数)团队发起评审请求的次数,即“申请开怪”的次数。
    Nrequested=评审请求总数N_{\text{requested}} = \text{评审请求总数}
  2. N\_merged(成功合并的数量)通过评审并合并进主干的请求数,即“通关”的次数。
    Nmerged=成功合并数N_{\text{merged}} = \text{成功合并数}
  3. ×100%(百分比换算)便于在不同团队之间横向对比。
    ×100%=换算为百分比\times 100\% = \text{换算为百分比}
  4. R(通过率)若持续偏低,说明提交质量不稳定或评审标准模糊,该回头完善流程了。
    R=评审通过率R = \text{评审通过率}

文档应用

出版社再版图书时,编辑最怕被问“这一版到底改了什么”。如果每版只是用新文件“定稿.pdf”粗暴替换旧文件,历史就彻底消失了。版本控制让文档的每一步演进都有据可查,这是它区别于“另存为”的根本所在。

技术文档有三个天然痛点:多人合并困难、变更历史不明、回退风险大。Git 以纯文本方式处理 Markdown 等格式,差异对比可以精确到每一行——哪句话被删了、哪个标题被改了,一目了然。当新版本出现问题时,回退不再是“凭感觉找回备份”,而是基于变更记录精准运算:

就像读档后,你身上不会保留“读档之后才买到的道具”,回退到目标版本后,之后的修改也会消失。因此团队通常用 git revert 生成反向提交,保留完整历史轨迹——存档还在,随时可以再切换回来。

vtarget=vcurrent−∑i=t+1nΔi\displaystyle v_{\text{target}} = v_{\text{current}} - \sum_{i=t+1}^{n} \Delta_i
回退公式:目标版本 = 当前版本 − 目标版本之后所有变更。也就是说,把多余的增量“反着应用”一遍,就能回到想要的过去。
  1. v\_current(当前版本)文档目前所在的版本,通常是最新提交。
    vcurrent=当前文档版本v_{\text{current}} = \text{当前文档版本}
  2. Δᵢ(第 i 次变更)目标版本之后每次提交引入的增量,它们是需要被撤销的对象。
    Δi=目标版本之后的第 i 次变更\Delta_i = \text{目标版本之后的第 } i \text{ 次变更}
  3. 求和符号 Σ(收集变更)把目标之后的所有增量全部收集起来。
    ∑i=t+1nΔi=目标之后的所有增量\sum_{i=t+1}^{n} \Delta_i = \text{目标之后的所有增量}
  4. 减法(反向应用)把这些增量逐一反转,文档内容便回到目标版本。
    vcurrent−∑Δi=vtargetv_{\text{current}} - \sum \Delta_i = v_{\text{target}}

最佳实践

老玩家都明白:存档要命名规范(“主线通关前”“全收集前”)、要定期覆盖旧档、还要上传云盘防丢。版本控制的最佳实践与之完全同构:提交信息写清楚、仓库结构保持清晰、定期推送远程备份。习惯好,时间机器才靠得住。

提交信息是后人理解历史的唯一窗口。与其写“更新文档”,不如遵循约定式提交的格式,让每个存档点的含金量一眼可见:

规范的存档名让你在三个月后回溯时,只看列表就能判断每个存档的含金量。再配合“小步提交、定期推送、仓库按模块拆分”的习惯,团队新人也能迅速读懂整个项目的演进脉络——这才是版本控制从“工具”升华为“基础设施”的时刻。

提交信息=type(scope): subject\displaystyle 提交信息 = \text{type}(\text{scope}):\ \text{subject}
约定式提交:类型(影响范围): 一句话概述。例如 docs(intro): 改写安装说明,三个月后回看,依然秒懂这次提交做了什么。
  1. type(提交类型)标明这次修改的性质——docs 表示文档、fix 表示修复、feat 表示新功能。
    type∈{docs,fix,feat,⋯ }\text{type} \in \{\text{docs}, \text{fix}, \text{feat}, \cdots\}
  2. scope(影响范围)具体指向哪个章节或模块,帮助快速定位改动区域。
    scope=影响范围\text{scope} = \text{影响范围}
  3. subject(一句话概述)用一句话说清“改了什么、为什么改”。
    subject=简明修改说明\text{subject} = \text{简明修改说明}

AI 应用场景

提示词工程的版本化迭代

阶段:提示词开发与评估阶段

解决的问题:提示词工程师常靠“另存为”管理 prompt 草稿,无法追踪“哪个 prompt 版本产生了当前最优输出”,A/B 测试结果也难以回放。将 system prompt 与 few-shot 示例以 Markdown 或文本文件形式纳入 Git 后,每次调整都形成一次提交,评估指标可绑定到具体提交,回到最佳版本只需一条命令——就像游戏里精准读取“高光时刻”的存档。

具体案例:某客服机器人团队将 system_prompt.md 与示例库放进 Git 仓库,上线前在 main 分支打 tag。线上回答质量下降时,直接 diff 出“这次 prompt 改了什么”,一分钟定位回归原因。

训练数据集说明文档的版本化

阶段:数据准备与模型复现阶段

解决的问题:数据集版本一变,实验结论就可能失效。标注规范、采集说明等文档纳入版本管理后,每个训练实验都能精确对应到当时的文档状态,模型复现不再是玄学,而是可验证的工程过程。

具体案例:某团队训练多语言模型,每次调整数据清洗规则都同步提交 docs/data_policy.md,训练脚本把该文件的 commit hash 写入实验元数据。追溯问题时,先切到对应提交,再看当时的规范和结论,团队复盘效率大幅提升。

AI 辅助写作的技术文档审核

阶段:内容生成与人工审核阶段

解决的问题:AI 生成初稿 → 人工修订 → 评审发布,若中间环节不留痕,人改了什么、AI 哪里跑偏都说不清。让 AI 输出直接落在 Git 分支上,人工修订以提交形式叠加,评审时查看 diff 就能精准看到 AI 与人的分工边界。

具体案例:技术文档团队用大模型生成 API 参考初稿,推送到 feature/ai-draft 分支,工程师在该分支上逐段修订并提交,合并到 main 时保留完整评审记录,最终文档既有人类判断力,又有 AI 生产力。

Python 演示

python68 行
import hashlibimport json  class Commit:    """一次提交,相当于游戏里的一个存档点。"""     def __init__(self, message, parent, files):        self.message = message      # 存档说明,如"补充安装章节"        self.parent = parent        # 父提交的哈希,构成时间链        self.files = files          # 该版本所有文件的内容快照        self.hash = self._hash()    # 用哈希值作为存档编号     def _hash(self):        payload = json.dumps(            {"message": self.message, "parent": self.parent,             "files": self.files},            sort_keys=True, ensure_ascii=False        )        return hashlib.sha1(payload.encode("utf-8")).hexdigest()[:8]  class MiniGit:    """迷你版本控制系统:提交、查看历史、回退。"""     def __init__(self):        self.commits = []           # 所有存档点        self.head = None            # 当前指向的存档编号        self.workspace = {}         # 正在编辑的文件内容     def edit(self, filename, content):        self.workspace[filename] = content     def save(self, message):        """把当前文件内容存成一个新版本。"""        commit = Commit(message, self.head, dict(self.workspace))        self.commits.append(commit)        self.head = commit.hash        return commit.hash     def log(self):        """列出从新到旧的提交历史。"""        return [(c.hash, c.message) for c in reversed(self.commits)]     def rollback(self, target_hash):        """回退到指定存档点,工作区恢复成当时的文件。"""        for commit in self.commits:            if commit.hash == target_hash:                self.workspace = dict(commit.files)                self.head = target_hash                return target_hash        raise ValueError("找不到存档点: " + target_hash)  if __name__ == "__main__":    repo = MiniGit()    repo.edit("guide.md", "# 使用手册\n## 安装")    v1 = repo.save("初稿完成")    repo.edit("guide.md", "# 使用手册\n## 安装\n## 配置")    v2 = repo.save("补充配置章节")    repo.edit("guide.md", "# 使用手册\n## 安装\n## 配置\n## FAQ")    v3 = repo.save("新增常见问题")    print("提交历史:")    for h, m in repo.log():        print(" ", h, m)    repo.rollback(v1)    print("回退到 v1 后的 guide.md:")    print(repo.workspace["guide.md"])
目的:用 60 行代码实现一个迷你 Git——支持提交存档、查看历史、回退版本,演示版本控制的三个核心行为。
  1. self.hash = self._hash()用内容哈希给存档编号,相同内容在任何机器上都会得到相同编号
  2. payload = json.dumps(...)把元信息序列化,才能计算稳定哈希
  3. commit = Commit(message, self.head, dict(self.workspace))记录父提交哈希,形成时间链,这是“时间线”的骨架
  4. self.commits.append(commit)存档入库,之后才能遍历检索
  5. self.workspace = dict(commit.files)回退的本质是整体替换工作区内容
  6. raise ValueError("找不到存档点: " + target_hash)找不到目标版本直接报错,避免静默失败

常见误区

误区我是写文档的,不是程序员,版本控制是开发团队的事。文档用 Word 的修订和“另存为新版本”就能解决,何必学 Git?

正解Git 管理的是任何文本文件的变更历史,Markdown、LaTeX、CSV、配置文件统统适用。相比 Word 修订,Git 支持多人并行编辑同一文件而不会互相锁死,回退粒度精确到每次提交,还能用 diff 看清任意两版之间每一行的变化。这正是“存档系统”对“修订痕迹”的降维打击。技术文档纳入 Git 后,发布流程、评审流程还能与代码一起自动化。

为何常见:早期版本控制教程几乎全以代码为例,而 Word 的修订在日常场景中看起来“够用”,让人误以为它就是文档版本管理的全部。

误区一天提交十几次,会不会显得我很啰嗦?还是攒到下班前一次性提交,干净利落,更像一个严谨的专家。

正解恰恰相反,频繁小步提交是行业推荐做法。每个提交只封装一个逻辑变更(比如“补充安装章节”“修正错别字”),一旦某次修改引入问题,可以精准回退到该提交之前;评审时小提交也更易读懂。攒一个大提交会把多个无关变更混在一起,回退时“一刀切”误伤无辜。提交是过程记录,发布才需要完整交付。

为何常见:人们容易把“提交”等同于“发布”,觉得频繁提交是在暴露粗糙的中间过程,其实版本控制的价值恰恰在于忠实记录这个过程。

误区我一不小心执行了回退,同事这几天的改动是不是全没了?版本回退太危险了,以后还是少用为妙。

正解要区分两种回退。本地尚未推送的分支,用 reset 移动当前指针,若同事已基于该分支工作则需谨慎;已推送远程、多人共享的分支,用 git revert 生成一次“反向提交”,把目标版本之后的内容倒回去,而历史记录里每个人的提交都原样保留。回退不是删除时间线,而是“读档”——存档还在,随时可以再切回来。

为何常见:混淆了 reset 与 revert 两种操作,也高估了回退的破坏力,低估了 Git 历史不可变的设计初衷。

误区管理文档版本很简单,每改一版就另存为“最终版_v2”“最终版_v3_真最终”,文件名里带上日期和负责人不就行了?

正解文件名式版本管理丢失了最宝贵的资产:变更原因和演进脉络。没人知道“v3 真最终”相比“v2“改了什么、为什么改,也无法多人并行协作,更不可能自动对比任意两版的差异。Git 的提交记录天生携带”谁、何时、为什么改”的元信息,diff 让每次变化一目了然——相当于每个存档点都自动写好了存档日志。

为何常见:小团队轻量协作下,文件复制起步成本极低,而 Git 有学习门槛,“够用就好”的惯性让人迟迟不肯迈出第一步。

面试题

Q1. Git 中的"commit"操作最接近游戏中的哪种行为?

单选题 · easy

  • A.删除一个旧存档
  • B.保存当前游戏进度← 正确答案
  • C.回退到上一个关卡
  • D.查看角色的属性面板

答案:B。commit 就是把当前工作区的状态固化成一个不可变的存档点,与游戏中“保存进度”一一对应。删除旧档对应清除分支或记录,回退对应 revert/reset,查看属性则更像 status/diff。

Q2. 以下哪类内容最适合用 Git 来管理?

单选题 · easy

  • A.编译生成的二进制可执行程序
  • B.Markdown 格式的技术文档← 正确答案
  • C.存放密钥的本地配置文件
  • D.程序运行产生的临时缓存文件

答案:B。Git 擅长管理文本文件的变更。Markdown 是纯文本,diff 精确到行,是理想对象。二进制程序难以对比差异,密钥文件有泄露风险,缓存文件则是噪声,都不适合入库。

Q3. git pull 在 Git 中相当于哪两个操作的组合?

单选题 · mid

  • A.git add 与 git commit 的组合
  • B.git fetch 与 git merge 的组合← 正确答案
  • C.git branch 与 git checkout 的组合
  • D.git push 与 git rebase 的组合

答案:B。pull 先从远程取回最新提交(fetch),再把它合并进当前分支(merge),相当于“同步云存档到本地并读入”。add/commit 是本地保存,push 是上传,branch/checkout 是管理分支,均与同步无关。

Q4. 分支合并出现冲突时,正确的处理方式是?

单选题 · mid

  • A.用强制推送覆盖对方的修改
  • B.手动修改冲突标记后提交← 正确答案
  • C.直接删除冲突的分支重来
  • D.忽略冲突继续推送代码

答案:B。冲突意味着主线和分支改了同一处内容,需要人工判断保留谁。手动编辑冲突标记、确认最终内容再提交是唯一稳妥做法。强推会覆盖他人劳动,删分支和忽略冲突都会丢失修改或破坏仓库。

Q5. 关于频繁小步提交的优势,下列哪些说法正确?

多选题 · mid

  • A.出错时定位问题更精准← 正确答案
  • B.每次变更原因清晰可查← 正确答案
  • C.可以完全避免合并冲突
  • D.提交记录永远保持简洁

答案:AB。小步提交让每个提交只含一个逻辑变更,回退定位精准,评审时原因清晰。但它不能完全避免冲突——冲突源于并发修改同一处内容,与提交粒度无关;记录是否简洁也取决于提交信息质量,而非提交次数。

Q6. 三向合并中“共同祖先”的主要作用是什么?

单选题 · hard

  • A.决定合并后使用哪个分支名
  • B.判断哪一侧发生了真正的修改← 正确答案
  • C.计算两个分支的大小差异
  • D.指定合并后的提交说明

答案:B。共同祖先是分叉前的版本,是合并的裁判基准。只有对照它,Git 才能判断某段代码是主线新改的、分支新改的,还是两边都没动过。它不参与命名、大小计算或提交说明,只回答“谁才是新改动”。

Q7. 文档版本回退(rollback)的本质是什么?

单选题 · hard

  • A.删除目标版本之后的所有提交记录
  • B.基于变更记录把内容恢复到目标版本← 正确答案
  • C.将远程仓库完全清空并重新初始化
  • D.复制一份新仓库避免原始数据损坏

答案:B。回退不是删除时间线,而是把目标版本之后的变更“反向应用”,使工作区内容回到目标状态,历史提交依然保留。删除记录是 reset 的破坏性用法,清空仓库与复制仓库都不是版本控制的回退语义。

Q8. 下列哪些做法有助于团队文档协作?

多选题 · mid

  • A.提交信息写清楚修改原因← 正确答案
  • B.将大体积二进制文件提交进仓库
  • C.评审通过后再合并到主干← 正确答案
  • D.每日将本地改动推送到远程← 正确答案

答案:ACD。清晰提交信息让历史可读,评审保证质量,每日推送实现异地备份与进度同步。大体积二进制文件会让仓库膨胀、diff 失效,应使用 Git LFS 或独立存储,而非直接入库。

Q9. 远程仓库在团队协作中的作用相当于什么?

单选题 · easy

  • A.个人的本地草稿文件夹
  • B.团队共用的云端存档服务器← 正确答案
  • C.单个成员的编译缓存目录
  • D.本地编辑器的自动补全插件

答案:B。远程仓库是所有成员共享的权威存档点,大家推送自己的提交、拉取他人的提交,正如多人游戏共用一个云存档。本地草稿、编译缓存、编辑器插件都是单机概念,与协作无关。

Q10. 使用 Git 管理 Markdown 文档的优势包括哪些?

多选题 · hard

  • A.可精确查看任意版本的差异← 正确答案
  • B.支持多人并行修改同一章节← 正确答案
  • C.二进制图片自动完成合并
  • D.回退后历史记录依然保留← 正确答案

答案:ABD。Markdown 是纯文本,Git 能逐行 diff,让任意版本对比成为可能;分支机制支持多人并行编辑后合并;revert 回退保留完整历史。但二进制图片无法自动合并,冲突时仍需人工选择,这不是 Git 的适用范围。