代码简化重构
下载地址
https://www.zhengdianxue.com/wp-content/uploads/skills/org-b6kzcl68--code-simplification.zip将提示词发送给你的 AI 安装该 skills
请根据 https://skillhub.cn/install/skillhub.md,安装 @org-b6kzcl68/code-simplification。- "
- 在不改变代码行为的前提下降低复杂度、提升可读性与可维护性的代码简化技能。遵循五大原则:精确保留行为、遵循项目约定、清晰优先于炫技、防止过度简化、只改动当前范围
- 提供嵌套逻辑、长函数、误导性命名、重复代码等具体识别信号,以及 TypeScript、Python、React 等语言的渐进式改写示例,强调增量修改、每步运行测试、重构与功能变更分开提交、超大范围改动借助自动化工具完成。Use when 功能已通过测试但实现显得臃肿、代码审查中发现可读性或复杂度问题、需要重构时间压力下写出的代码,或合并变更后引入了重复与不一…
阅读全文 (展开查看完整说明)
概述
代码简化
灵感来自 Claude Code Simplifier 插件。此处改编为模型无关、流程驱动的技能,适用于任何 AI 编码智能体。
概述
通过降低复杂度来简化代码,同时精确保留原有行为。目标不是更少的行数——而是更容易阅读、理解、修改和调试的代码。每次简化都必须通过一个简单的测试:「新加入团队的成员理解这段代码会不会比理解原代码更快?」
何时使用
- 功能已实现且测试通过,但实现感觉比应有的更笨重
- 代码审查中被指出可读性或复杂度问题时
- 遇到深层嵌套逻辑、超长函数或含糊不清的命名时
- 重构在时间压力下写出的代码时
- 整合散落在多个文件中的相关逻辑时
- 合并变更后发现引入了重复或不一致时
何时不使用:
- 代码已经干净可读——不要为了简化而简化
- 你还不理解代码在做什么——先理解,再简化
- 代码是性能关键路径,而「更简单」的版本会可测地变慢
- 你即将整体重写该模块——简化一次性代码是浪费精力
五大原则
1. 精确保留行为
不要改变代码做什么——只改变它如何表达。所有输入、输出、副作用、错误行为和边界情况必须保持完全一致。如果不确定某次简化能否保留行为,就不要做。
ASK BEFORE EVERY CHANGE:
→ Does this produce the same output for every input?
→ Does this maintain the same error behavior?
→ Does this preserve the same side effects and ordering?
→ Do all existing tests still pass without modification?2. 遵循项目约定
简化是让代码与代码库更一致,而不是强加外部偏好。简化之前:
1. Read CLAUDE.md / project conventions
2. Study how neighboring code handles similar patterns
3. Match the project's style for:
- Import ordering and module system
- Function declaration style
- Naming conventions
- Error handling patterns
- Type annotation depth破坏项目一致性的简化不是简化——而是折腾。
3. 清晰优先于炫技
当紧凑版本需要停下来动脑才能解析时,显式代码优于紧凑代码。
// UNCLEAR: Dense ternary chain
const label = isNew ? 'New' : isUpdated ? 'Updated' : isArchived ? 'Archived' : 'Active';
// CLEAR: Readable mapping
function getStatusLabel(item: Item): string {
if (item.isNew) return 'New';
if (item.isUpdated) return 'Updated';
if (item.isArchived) return 'Archived';
return 'Active';
}// UNCLEAR: Chained reduces with inline logic
const result = items.reduce((acc, item) => ({
...acc,
[item.id]: { ...acc[item.id], count: (acc[item.id]?.count ?? 0) + 1 }
}), {});
// CLEAR: Named intermediate step
const countById = new Map<string, number>();
for (const item of items) {
countById.set(item.id, (countById.get(item.id) ?? 0) + 1);
}4. 保持平衡
简化有一种失败模式:过度简化。警惕这些陷阱:
- 过度内联——移除一个为概念命名的辅助函数,会让调用点更难读
- 合并无关逻辑——两个简单函数合并成一个复杂函数并不是更简单
- 移除「不必要」的抽象——有些抽象的存在是为了可扩展性或可测试性,而不是复杂度
- 以行数为优化目标——行数更少不是目标;更容易理解才是
5. 范围限定在已改动之处
默认只简化最近修改过的代码。避免顺手重构无关代码,除非被明确要求扩大范围。无范围限制的简化会给 diff 制造噪音,并带来意外回归的风险。
简化流程
第 1 步:动手之前先理解(切斯特顿栅栏)
在修改或移除任何东西之前,先理解它为什么存在。这就是切斯特顿栅栏:如果你看到横在路上的栅栏,却不明白它为什么在那里,不要拆掉它。先弄清原因,再判断这个原因是否仍然成立。
BEFORE SIMPLIFYING, ANSWER:
- What is this code's responsibility?
- What calls it? What does it call?
- What are the edge cases and error paths?
- Are there tests that define the expected behavior?
- Why might it have been written this way? (Performance? Platform constraint? Historical reason?)
- Check git blame: what was the original context for this code?如果回答不了这些问题,你还没有准备好简化。先读更多上下文。
第 2 步:识别简化机会
扫描以下模式——每一个都是具体信号,而不是模糊的坏味道:
结构复杂度:
| 模式 | 信号 | 简化方式 |
|---|---|---|
| 深层嵌套(3 层以上) | 控制流难以跟踪 | 把条件提取为守护子句或辅助函数 |
| 超长函数(50 行以上) | 多重职责 | 拆分为命名清晰、聚焦的函数 |
| 嵌套三元表达式 | 需要脑内维护栈来解析 | 替换为 if/else 链、switch 或查找对象 |
| 布尔参数开关 | doThing(true, false, true) | 替换为选项对象或独立函数 |
| 重复条件判断 | 同一个 if 检查出现在多处 | 提取为命名良好的谓词函数 |
命名与可读性:
| 模式 | 信号 | 简化方式 |
|---|---|---|
| 泛化命名 | data、result、temp、val、item | 重命名为描述内容的名字:userProfile、validationErrors |
| 缩写命名 | usr、cfg、btn、evt | 使用完整单词,除非缩写是通用的(id、url、api) |
| 误导性命名 | 名为 get 的函数同时修改状态 | 重命名以反映实际行为 |
| 解释「做什么」的注释 | count++ 上方的 // increment counter | 删掉注释——代码本身已足够清楚 |
| 解释「为什么」的注释 | // Retry because the API is flaky under load | 保留——它们承载了代码无法表达的意图 |
冗余:
| 模式 | 信号 | 简化方式 |
|---|---|---|
| 重复逻辑 | 同样的 5 行以上代码出现在多处 | 提取为共享函数 |
| 死代码 | 不可达分支、未使用变量、被注释掉的代码块 | 移除(先确认确实已死) |
| 不必要的抽象 | 不增加任何价值的包装层 | 内联包装层,直接调用底层函数 |
| 过度设计的模式 | 工厂的工厂、单策略的策略模式 | 替换为简单的直接实现 |
| 冗余类型断言 | 断言成一个本已可推断的类型 | 移除断言 |
第 3 步:增量应用变更
一次只做一处简化。每次改动后运行测试。重构变更与功能或缺陷修复变更分开提交。 一个既重构又加功能的 PR 等于两个 PR——拆开它们。
FOR EACH SIMPLIFICATION:
1. Make the change
2. Run the test suite
3. If tests pass → commit (or continue to next simplification)
4. If tests fail → revert and reconsider避免把多处简化打包成一个未测试的大改动。如果出了问题,你需要知道是哪一处简化导致的。
500 行规则: 如果一次重构会触及超过 500 行,应投入自动化手段(codemod、sed 脚本、AST 变换)而不是手工修改。这个规模的手动编辑容易出错,而且审查起来令人疲惫。
第 4 步:验证结果
所有简化完成后,退一步评估整体:
COMPARE BEFORE AND AFTER:
- Is the simplified version genuinely easier to understand?
- Did you introduce any new patterns inconsistent with the codebase?
- Is the diff clean and reviewable?
- Would a teammate approve this change?如果「简化后」的版本更难理解或更难审查,回滚。并非每次简化尝试都会成功。
各语言专项指南
TypeScript / JavaScript
// SIMPLIFY: Unnecessary async wrapper
// Before
async function getUser(id: string): Promise<User> {
return await userService.findById(id);
}
// After
function getUser(id: string): Promise<User> {
return userService.findById(id);
}
// SIMPLIFY: Verbose conditional assignment
// Before
let displayName: string;
if (user.nickname) {
displayName = user.nickname;
} else {
displayName = user.fullName;
}
// After
const displayName = user.nickname || user.fullName;
// SIMPLIFY: Manual array building
// Before
const activeUsers: User[] = [];
for (const user of users) {
if (user.isActive) {
activeUsers.push(user);
}
}
// After
const activeUsers = users.filter((user) => user.isActive);
// SIMPLIFY: Redundant boolean return
// Before
function isValid(input: string): boolean {
if (input.length > 0 && input.length < 100) {
return true;
}
return false;
}
// After
function isValid(input: string): boolean {
return input.length > 0 && input.length < 100;
}Python
# SIMPLIFY: Verbose dictionary building
# Before
result = {}
for item in items:
result[item.id] = item.name
# After
result = {item.id: item.name for item in items}
# SIMPLIFY: Nested conditionals with early return
# Before
def process(data):
if data is not None:
if data.is_valid():
if data.has_permission():
return do_work(data)
else:
raise PermissionError("No permission")
else:
raise ValueError("Invalid data")
else:
raise TypeError("Data is None")
# After
def process(data):
if data is None:
raise TypeError("Data is None")
if not data.is_valid():
raise ValueError("Invalid data")
if not data.has_permission():
raise PermissionError("No permission")
return do_work(data)React / JSX
// SIMPLIFY: Verbose conditional rendering
// Before
function UserBadge({ user }: Props) {
if (user.isAdmin) {
return <Badge variant="admin">Admin</Badge>;
} else {
return <Badge variant="default">User</Badge>;
}
}
// After
function UserBadge({ user }: Props) {
const variant = user.isAdmin ? 'admin' : 'default';
const label = user.isAdmin ? 'Admin' : 'User';
return <Badge variant={variant}>{label}</Badge>;
}
// SIMPLIFY: Prop drilling through intermediate components
// Before — consider whether context or composition solves this better.
// This is a judgment call — flag it, don't auto-refactor.常见借口
| 借口 | 现实 |
|---|---|
| 「能跑就行,别动它」 | 难读的能跑代码,坏掉时也会很难修。现在简化,为未来每次修改节省时间。 |
| 「行数少一定更简单」 | 一行嵌套三元表达式不比五行 if/else 简单。简洁取决于理解速度,不是行数。 |
| 「我顺手把这段无关代码也简化一下」 | 无范围限制的简化会产生嘈杂的 diff,并给无意改动的代码带来回归风险。保持专注。 |
| 「类型本身就是文档」 | 类型描述结构,不描述意图。命名良好的函数解释「为什么」,胜过类型签名解释「做什么」。 |
| 「这个抽象以后可能有用」 | 不要保留投机性抽象。现在不用就是没有价值的复杂度。删掉它,需要时再加回来。 |
| 「原作者一定有他的理由」 | 也许。查 git blame——应用切斯特顿栅栏。但累积的复杂度往往没有理由,只是高压迭代的残留物。 |
| 「我边加这个功能边重构」 | 重构与功能开发分开。混合变更更难审查、回滚,也更难在历史中理解。 |
危险信号
- 简化需要修改测试才能通过(你很可能改变了行为)
- 「简化后」的代码比原来更长、更难读
- 按照个人偏好而非项目约定重命名
- 以「让代码更干净」为由移除错误处理
- 简化自己尚未完全理解的代码
- 把大量简化打包成一个难以审查的大提交
- 未被要求就重构当前任务范围之外的代码
验证
完成一轮简化后:
- [ ] 所有现有测试不加修改即可通过
- [ ] 构建成功且没有新的警告
- [ ] Linter/formatter 通过(无样式回归)
- [ ] 每处简化都是可审查的增量变更
- [ ] diff 干净——没有混入无关变更
- [ ] 简化后的代码遵循项目约定(对照 CLAUDE.md 或等效文件检查)
- [ ] 没有移除或削弱任何错误处理
- [ ] 没有遗留死代码(未使用的导入、不可达分支)
- [ ] 同事或审查智能体会认可此变更是一项净改进