用 Cursor AI 助手做代码重构实战

可视化演示

展示代码异味检测与热点定位、AI辅助重构五阶段流水线、以及重构前后代码质量指标对比。

初识重构：给老房子做一次翻新

翻新老房子的第一课，是搞清楚它和“推倒重建”的区别。重建意味着新的地基、新的外墙，整栋楼的外观和结构全部改变；而翻新只动内部格局——墙可以重新刷，柜子可以重新摆，但承重墙绝对不能碰，房间数量和外轮廓保持不变。这就像重构的定义：在不改变代码外部行为的前提下，调整内部结构，让它更容易读懂、更容易修改。外部行为不变意味着功能、接口、运行结果都和之前一模一样——用户看到的一切照旧，只是“住”在里面的人觉得舒服了。

那什么时候该给代码安排一次翻新呢？如果你发现自己“加一个功能要改五个文件”“读自己上个月写的代码都要想半天”，翻新的时机就到了。持续重构的收益是复利增长的：代码越干净，改动越快；改动越快，越敢改、越敢加功能。反过来，代码越乱越不敢动，越不敢动越乱，这就是技术债的恶性循环。用一句话说：重构不是给代码“美容”，而是给未来的每一位开发者省时间。

更重要的是，重构从来不应该是“心血来潮的大工程”，而应该像定期打扫房间一样成为日常习惯。每天花十分钟让 AI 帮你整理一个函数，一个月后回头看，整栋楼的内部结构已经脱胎换骨。这个认知到位了，下面的每一招才学得进去。

$$\displaystyle R = M \times F - C - K$$

1. 净收益 R：这笔“翻新工程”到底值不值，用净收益来衡量，结果为正就值得动手。

$$R$$

2. 可维护性提升 M：重构后代码更好读、更好改的程度，相当于翻新后新增的可用空间。

$$M$$

3. 未来修改次数 F：这块代码今后还会被改多少回，改得越频繁，重构的复利收益越大。

$$F$$

4. 成本与风险 C + K：重构花费的工时（成本 C）加上可能引入回归的损失（风险 K），都要从收益中扣除。

$$C + K$$

就像翻新要趁漏水之前动手，重构也要在坏味道蔓延之前开始。记住一条铁律：承重墙不能动——外部行为不变，这是后面每一节反复强调的安全红线。

重复代码提取：搬走一模一样的家具

翻新时最抓狂的发现是什么？客厅、卧室、书房各摆着一模一样的组合柜。买的时候花了三份钱，摆起来占了三倍地方，更麻烦的是——如果其中一套柜子的铰链坏了，你得在三套柜子里挨个修，漏修一套，下次还得再坏一次。代码里的重复代码块，就是这些一模一样的家具。同一段逻辑被复制到多个函数后，Bug 一旦出现要改 N 处，漏改一处就埋下一颗雷。

重复代码（Duplicated Code）是代码坏味道里最经典的一种。好在 AI 助手非常擅长处理它：你选中两处相似代码，告诉 Cursor“提取为公共函数”，它会分析两处的差异，把共同部分包装成一个新函数，差异点变成参数，然后在所有原位置替换成对新函数的调用。整个过程就像把一个多功能组合柜安在公共区域，每个房间只需要挂一面“镜子”——调用语句——就能随时取用柜子里的东西。

提取函数（Extract Function）的本质就是三步：识别重复片段、把公共部分包装成新函数、在原来位置替换为调用。其中参数设计是关键中的关键：共同点进函数体，不同点进参数列表。Cursor 的厉害之处在于，它不只是处理你选中的那两段，还会顺着调用关系找到所有隐藏的重复点，一并更新调用点。

$$\displaystyle Dup = \frac{L_{dup}}{L_{total}} \times 100\%$$

1. 重复行数 L_dup：所有重复出现的代码行数量之和，对应翻新时发现的“同款家具”总件数。

$$L_{dup}$$

2. 总行数 L_total：被分析的函数或文件的总行数，作为衡量重复严重程度的基准线。

$$L_{total}$$

3. 重复率 Dup：重复行占总行的百分比，超过 20% 就说明该做一次提取函数的施工了。

$$Dup = \frac{L_{dup}}{L_{total}} \times 100\%$$

翻新之后，那三个位置不再摆放实体柜子，只需要一面“镜子”指向同一个衣柜。家具少了两套，收纳能力反而更强——代码行数变少了，但每个调用点的意图都更清楚了。

条件逻辑简化：打通迷宫式隔断

老房子里最让人头疼的是隔断墙：想去客厅必须穿三个门、拐五个弯，想放个大沙发却发现路径太窄根本搬不进去。翻新师傅的建议是：把非承重的隔断墙打通，用玻璃门或矮柜做软隔断。代码里的 if 套 if 再套 if，就是这些隔断墙，而圈复杂度会告诉你这栋“逻辑迷宫”到底有多绕。

复杂条件逻辑的常见表现：多层嵌套、判断条件超长、真假分支的逻辑散落各处。简化手段主要有三招：第一招卫语句（Guard Clause），把异常情况和前置条件用提前 return 甩出去，让主线逻辑保持扁平；第二招合并条件（Consolidate Condition），把分散的零散判断归并成一个语义清晰的函数；第三招多态替换，用类型分发替代一长串 if-else 类型判断。三招的共同目标只有一个：让阅读主线代码的人不再迷路。

用 Cursor 简化条件的实操非常顺滑：选中一整段嵌套代码，输入“用卫语句重写这段，保持行为不变”，AI 会输出扁平化版本并保留完整语义。你还可以让它先算一遍重构前后的圈复杂度，用数字验证“迷宫”真的被拆掉了。

$$\displaystyle V(G) = D + 1$$

1. 圈复杂度 V(G)：衡量条件逻辑“迷宫程度”的指标，值越高代码越难读、越难测试。

$$V(G)$$

2. 决策节点数 D：if、while、for、switch 等会产生分支的语句总数，每多一个决策就多一条岔路。

$$D$$

3. 基线加一：没有分支时也至少有一条主路径，所以用加 1 作为起点。

$$D + 1$$

墙打通之后，从客厅走到书房的路径从五米变成两米；条件扁平之后，从读代码到看懂逻辑的时间也缩短一半。前提是：施工前确认那堵墙不是承重墙——业务语义必须原样保留，这是简化条件永远不能越过的红线。

坏味道清除：清理陈年杂物

翻新最爽的一步是清理杂物间：旧杂志、坏家电、不知道干什么用的螺丝钉，统统分类处理。能用但碍事的东西，要么移交储物间，要么直接扔掉。代码里也有类似的“陈年杂物”，我们叫它坏味道（Code Smell）——不是 Bug，但看着难受、留着埋雷。坏味道不会立刻让系统崩掉，但它会像杂物间里的霉味一样，悄悄腐蚀后来者对这个项目的信心。

常见坏味道有四种。第一种魔法数字（Magic Number）：代码里直接冒出 86400、0.618 这种含义不明的常量，等于杂物堆里没贴标签的螺丝钉；第二种超长函数：一个函数干十件事，等于一个房间同时当卧室、厨房、车库；第三种命名模糊：变量叫 a、temp，函数叫 handle_data，等于所有柜子都不贴标签；第四种过度耦合：改 A 必炸 B，等于房间之间共用一根没装阀门的水管。

Cursor 清除坏味道的招式非常实用：魔法数字提出为常量并自动命名；超长函数按“单一职责”拆分成多个小函数并生成初步骨架；模糊命名结合上下文给出语义化建议。每一项改动都小到可以逐条 review，不需要一次清理整栋楼——这正是 AI 辅助重构的优势：勤劳、快速、不厌其烦。

$$\displaystyle P_{magic} = \frac{N_{magic}}{N_{literal}} \times 100\%$$

1. 魔法数字个数 N_magic：代码中含义不明的裸常量数量，比如 86400、0.618 这类直接出现的数字。

$$N_{magic}$$

2. 字面量总数 N_literal：所有直接出现的数字、字符串字面量的总数量，作为衡量基准。

$$N_{literal}$$

3. 魔法数字率 P_magic：比值越高，说明代码里需要“翻译”的杂物越多，越该启动清理。

$$P_{magic} = \frac{N_{magic}}{N_{literal}} \times 100\%$$

杂物清了，储物间归位，翻新才算完整。坏味道清得越干净，后续每一次施工——无论是加功能还是修 Bug——都会省下大量心力。趁杂物还少的时候动手，永远比塞满后的大扫除轻松。

上下文理解：看得懂整栋楼的 AI 设计师

为什么我们不愿意请一个只看过客厅照片的实习生来翻新？因为他不知道水管走向、梁柱位置、配电箱在哪，动哪堵墙都可能闯祸。而装修公司的首席设计师会先通读整栋楼的图纸，再给出方案。Cursor 就是那个能读懂整栋“代码楼”的设计师，这是它和普通聊天工具最本质的差别。

Cursor 的核心能力是项目级上下文理解：它对整个代码仓库建立索引，当你提出重构需求时，能自动定位相关的文件、追踪调用链与依赖关系，再结合仓库已有的代码风格生成建议。普通聊天工具只看得见你贴过去的那几段代码，就像只看一张客厅照片；Cursor 看得见整栋楼，清楚这个函数被谁调用、那个常量在哪里定义、这个模块和哪个模块耦合。正因如此，它给出的重构建议才“靠谱”。

使用时有三个层面值得注意：第一，确认索引覆盖了整个仓库，而不是只索引了当前打开的文件；第二，提问时用 @ 符号圈定相关文件，让 AI 的注意力更聚焦；第三，要意识到 AI 理解的“相关”未必是你要的范围，关键文件的建议仍需人工把关。上下文覆盖率越高，建议的落地率越高。

$$\displaystyle Cover = \frac{F_{related}}{F_{total}} \times 100\%$$

1. 相关文件数 F_related：AI 在生成建议时实际参考的仓库文件数量，对应设计师通读的图纸张数。

$$F_{related}$$

2. 仓库文件总数 F_total：整个项目的文件总数量，是衡量覆盖率的分母。

$$F_{total}$$

3. 上下文覆盖率 Cover：覆盖越高，建议越贴合项目全局，越不容易踩到隐藏的承重墙。

$$Cover = \frac{F_{related}}{F_{total}} \times 100\%$$

设计师看得懂全楼图纸，才能准确告诉你哪堵墙可以拆、哪堵是承重墙。Cursor 的“全楼视角”，正是我们敢让它动手重构的底气来源——它知道每一块砖的位置，才敢给出“推墙”的建议。

安全重构：承重墙绝对不能动

翻新最怕什么？施工队把承重墙砸了，整栋楼开裂甚至倒塌。代码重构最怕的事同理：改动悄悄改变了外部行为，线上故障顺手就来，用户半夜收到报错短信。所以专业翻新队的铁律是：先画图纸、标注承重墙、小步施工、每步验收。这四个动作翻译到代码世界，就是安全重构（Safe Refactoring）的全部秘密。

安全重构三板斧。第一板斧是测试保障：重构开始前必须有足够的测试覆盖，测试就是施工方的“水平仪”——没有它，你根本不知道墙砌歪没有。第二板斧是小步提交：每次重构只做一个小改动、运行测试、马上提交，把风险稀释到最小颗粒度；想一次改完整个模块再验证，等于一口气拆十堵墙再重新砌，出了事都不知道哪堵墙的问题。第三板斧是回归验证：用人工 review 加上 AI 对比，确认重构前后的行为完全一致。

Cursor 在安全重构中的角色很清晰：它帮你分析影响面（哪些文件会受牵连）、识别测试覆盖的盲区、对比重构前后的行为差异。但有个边界必须划清——AI 是“施工建议方”，不是“验收方”。最终签字确认的人是你。这就像设计师画出施工图，但每堵墙敲掉之前，工头还要亲自敲一敲、听一听声音。

$$\displaystyle Risk = Impact \times Coupling \times (1 - TestCoverage)$$

1. 影响面 Impact：一次改动会波及多少文件、多少处调用，相当于施工范围有多大。

$$Impact$$

2. 耦合度 Coupling：模块之间互相牵连的程度，耦合越高越容易牵一发动全身。

$$Coupling$$

3. 测试覆盖率 TestCoverage：自动化测试覆盖的代码比例，覆盖率越低，回归风险越高。

$$TestCoverage$$

4. 重构风险 Risk：三者相乘得到综合风险值，风险不可控时就该缩小施工范围、补足测试再动手。

$$Risk = Impact \times Coupling \times (1 - TestCoverage)$$

承重墙不能动，说的是外部行为不能变；小步施工，说的是每步都要验收。有了这两条铁律，翻新的胆子才会越来越大，楼也才敢越改越漂亮——安全，是所有大刀阔斧的前提。

实战流程：一次完整的翻新之旅

把前面学的所有招式串起来，就是一次完整翻新的施工流程：勘察现状、制定方案、动手施工、验收交付。用 Cursor 做重构，同样有一套固定的实战流程，照着走就能少踩坑、少返工。整个过程可以看成四个阶段，每一阶段都有明确产出。

第一步分析现状：让 Cursor 扫描指定模块，列出坏味道清单，说明改动范围和优先级。这相当于翻新前请设计师做全屋勘察，先把问题清单列全。第二步指令编写：给 AI 下指令时，描述目标加约束，例如“提取重复代码为函数，保持行为不变，不引入第三方依赖”。指令写得越清楚，AI 越少自由发挥，也就越少返工。第三步评估建议：逐条查看 AI 生成的 diff，检查逻辑等价性，这一步最考验你的代码功底，也是你作为“工头”的核心价值。第四步迭代确认：让 AI 做小步修改，每步跑测试、逐步确认，直到全部验收通过。

特别强调指令质量对效率的决定性影响。一个好指令包含四要素：目标（要完成什么）、边界（哪些不许动）、风格（遵循仓库现有规范）、验证方式（跑什么测试）。把这四要素固定成团队模板，还能沉淀成全组通用的重构规范——新人来了照模板提问，质量下限就有了保障。

$$\displaystyle E = \frac{P_{pass}}{N_{iter}}$$

1. 一次通过率 P_pass：AI 建议不经返工直接被采纳的比例，越接近 1 说明指令写得越清晰。

$$P_{pass}$$

2. 往返次数 N_iter：和 AI 之间“修改—确认”的回合数，返工越多，效率越低。

$$N_{iter}$$

3. 重构效率 E：一次通过率高、往返次数少，整场翻新就能又快又好地交付。

$$E = \frac{P_{pass}}{N_{iter}}$$

翻新的最后一步是交房验收。当你把钥匙交到下一个开发者手里时，他打开门会由衷感叹：这房子真好住。这就是重构的全部意义——你的代码，就是下一任“住客”的家。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""Mini Cursor refactoring demo: find duplicated code and extract a function.""" SAMPLE_CODE = '''\def checkout(user, item, qty):    user.balance -= item.price * qty    item.stock -= qty    save_order(user.id, item.id, qty) def return_item(user, item, qty):    user.balance -= item.price * qty    item.stock -= qty    save_order(user.id, item.id, qty)'''  def find_duplicate_blocks(source, min_lines=3, max_lines=6):    """Return identical consecutive line blocks that appear more than once."""    raw = source.splitlines()    n = len(raw)    seen = {}    blocks = []    for size in range(min_lines, max_lines + 1):        for i in range(n - size + 1):            key = tuple(raw[i:i + size])            if key not in seen:                seen[key] = i            else:                text = "\n".join(raw[i:i + size])                if text not in blocks:                    blocks.append(text)    return blocks  def extract_function(source, block, fn_name="apply_price_change"):    """Replace duplicated block with a call, then append new function."""    lines = block.splitlines()    indent = lines[0][:len(lines[0]) - len(lines[0].lstrip())]    call = indent + fn_name + "(user, item, qty)"    refactored = source.replace(block, call)    body = "\n".join("    " + ln.strip() for ln in lines)    new_fn = "def {}(user, item, qty):\n{}\n".format(fn_name, body)    return refactored + "\n" + new_fn  def main():    print("== before refactoring ==")    print(SAMPLE_CODE)    dup = find_duplicate_blocks(SAMPLE_CODE)    if not dup:        print("No duplicated block found.")        return    print("== duplicated blocks detected: {} found ==".format(len(dup)))    print(dup[0])    print("== after refactoring ==")    print(extract_function(SAMPLE_CODE, dup[0]))  if __name__ == "__main__":    main()

1. key = tuple(raw[i:i + size])把连续几行代码做成“指纹”，指纹完全一致就说明两处代码一模一样
2. if key not in seen:第一处出现的指纹先登记位置，等第二处出现时就能认出重复
3. blocks.append(text)记录下重复块原文，稍后整套提取都基于这段文本
4. indent = lines[0][:len(lines[0]) - len(lines[0].lstrip())]从原始代码提取缩进，保证替换后的调用语句和周围代码对齐
5. refactored = source.replace(block, call)一次性替换所有重复位置，对应 Cursor 的“自动更新调用点”
6. body = "\n".join(" " + ln.strip() for ln in lines)用统一缩进重建函数体，生成新的公共函数

常见误区

面试题