跳到主内容
智客 ZICQ

技能库 智客分类:设计创意 refactor

Refactor

手术代码重构以提高可维护性而不改变行为. 覆盖取出功能,重命名变量,分解出神功能,改善类型安全,消除代码嗅觉,并应用设计模式. 与再重建者相比没有那么激烈;用于逐步改进.

22300 安装量

官方网址:skills.sh

技能介绍

先看中文介绍;官方 description 原文单独保留,不改写 SKILL.md。

做什么

手术代码重构以提高可维护性而不改变行为. 覆盖取出功能,重命名变量,分解出神功能,改善类型安全,消除代码嗅觉,并应用设计模式. 与再重建者相比没有那么激烈;用于逐步改进.

何时用

当 :

代理如何加载

按 Agent Skills 渐进披露:启动时只加载 name 与 description(约 100 token);任务匹配后才读入整份 SKILL.md 正文;scripts/、references/、assets/ 仅在需要时再读。 本文件正文结构:Refactor、Overview、When to Use、Refactoring Principles、The Golden Rules、When NOT to Refactor。

文件分析

文件分析:这是一份仅含 SKILL.md 的指令型技能,代理激活后整份正文进入上下文。 正文约 639 行,超过规范建议的 500 行,激活时仍会整份载入。

官方 description(原文)

Surgical code refactoring to improve maintainability without changing behavior. Covers extracting functions, renaming variables, breaking down god functions, improving type safety, eliminating code smells, and applying design patterns. Less drastic than repo-rebuilder; use for gradual improvements.

RefactorOverviewWhen to UseRefactoring PrinciplesThe Golden RulesWhen NOT to RefactorCommon Code Smells & Fixes1. Long Method/FunctionBAD: 200-line function that does everythingGOOD: Broken into focused functions2. Duplicated CodeBAD: Same logic in multiple places

· 许可:MIT

来源分类:skills.sh agent-skill

SKILL.md 与 Agent 调用

官方规范 ↗
name
refactor
description
Surgical code refactoring to improve maintainability without changing behavior. Covers extracting functions, renaming variables, breaking down god functions, improving type safety, eliminating code smells, and applying design patterns. Less drastic than repo-rebuilder; use for gradual improvements.
许可
MIT
  1. 发现技能客户端向 Agent 提供名称与描述目录。
  2. 匹配与调用用户指定或任务匹配后,载入 SKILL.md 指令。
  3. 按需加载按步骤读取参考文档、使用脚本与素材。

具体调用语法与可用工具以目标 Agent 客户端为准。 查看调用机制说明 ↗

安装这个技能

Skills CLI ↗

先选择目标 Agent 和安装范围,保留技能包的附属文件,安装后检查客户端能否发现该技能。

交给 Agent 安装

复制安装指令给支持 Agent Skills 的代理,确认其中的目标目录与客户端匹配。

把 Agent Skill「refactor」安装到我的项目:SKILL.md 原文与官方 description 见 https://zicq.com/zh/skills/skl-6b34383096ed7214-%E9%87%8D%E6%9E%84.html
请存为 .cursor/skills/refactor/SKILL.md 或 .claude/skills/refactor/SKILL.md,frontmatter 的 name 与 description 保持原样,不要改写。

GitHub 完整包 ↗

终端安装 · Skills CLI

需要 Node.js 与 npx。先查看仓库技能列表,确认实际名称。

npx skills add 'https://github.com/github/awesome-copilot' --list

npx skills add 'https://github.com/github/awesome-copilot' --skill 'refactor'

CLI 会交互选择目标 Agent,默认安装到项目;用户级安装使用 -g。先通过查看命令核对仓库内容,再用 npx skills list 检查已安装技能。

阅读排版
--- name: refactor description: 'Surgical code refactoring to improve maintainability without changing behavior. Covers extracting functions, renaming variables, breaking down god functions, improving type safety, eliminating code smells, and applying design patterns. Less drastic than repo-rebuilder; use for gradual improvements.' license: MIT --- # Refactor ## Overview Improve code structure and readability without changing external behavior. Refactoring is gradual evolution, not revolution. Use this for improving existing code, not rewriting from scratch. ## When to Use Use this skill when: - Code is hard to understand or maintain - Functions/classes are too large - Code smells need addressing - Adding features is difficult due to code structure - User asks "clean up this code", "refactor this", "improve this" --- ## Refactoring Principles ### The Golden Rules 1. **Behavior is preserved** - Refactoring doesn't change what the code does, only how 2. **Small steps** - Make tiny changes, test after each 3. **Version control is your friend** - Commit before and after each safe state 4. **Tests are essential** - Without tests, you're not refactoring, you're editing 5. **One thing at a time** - Don't mix refactoring with feature changes ### When NOT to Refactor ``` - Code that works and won't change again (if it ain't broke...) - Critical production code without tests (add tests first) - When you're under a tight deadline - "Just because" - need a clear purpose ``` --- ## Common Code Smells & Fixes ### 1. Long Method/Function ```diff # BAD: 200-line function that does everything - async function processOrder(orderId) { - // 50 lines: fetch order - // 30 lines: validate order - // 40 lines: calculate pricing - // 30 lines: update inventory - // 20 lines: create shipment - // 30 lines: send notifications - } # GOOD: Broken into focused functions + async function processOrder(orderId) { + const order = await fetchOrder(orderId); + validateOrder(order); + const pricing = calculatePricing(order); + await updateInventory(order); + const shipment = await createShipment(order); + await sendNotifications(order, pricing, shipment); + return { order, pricing, shipment }; + } ``` ### 2. Duplicated Code ```diff # BAD: Same logic in multiple places - function calculateUserDiscount(user) { - if (user.membership === 'gold') return user.total * 0.2; - if (user.membership === 'silver') return user.total * 0.1; - return 0; - } - - function calculateOrderDiscount(order) { - if (order.user.membership === 'gold') return order.total * 0.2; - if (order.user.membership === 'silver') return order.total * 0.1; - return 0; - } # GOOD: Extract common logic + function getMembershipDiscountRate(membership) { + const rates = { gold: 0.2, silver: 0.1 }; + return rates[membership] || 0; + } + + function calculateUserDiscount(user) { + return user.total * getMembershipDiscountRate(user.membership); + } + + function calculateOrderDiscount(order) { + return order.total * getMembershipDiscountRate(order.user.membership); + } ``` ### 3. Large Class/Module ```diff # BAD: God object that knows too much - class UserManager { - createUser() { /* ... */ } - updateUser() { /* ... */ } - deleteUser() { /* ... */ } - sendEmail() { /* ... */ } - generateReport() { /* ... */ } - handlePayment() { /* ... */ } - validateAddress() { /* ... */ } - // 50 more methods... - } # GOOD: Single responsibility per class + class UserService { + create(data) { /* ... */ } + update(id, data) { /* ... */ } + delete(id) { /* ... */ } + } + + class EmailService { + send(to, subject, body) { /* ... */ } + } + + class ReportService { + generate(type, params) { /* ... */ } + } + + class PaymentService { + process(amount, method) { /* ... */ } + } ``` ### 4. Long Parameter List ```diff # BAD: Too many parameters - function createUser(email, password, name, age, address, city, country, phone) { - /* ... */ - } # GOOD: Group related parameters + interface UserData { + email: string; + password: string; + name: string; + age?: number; + address?: Address; + phone?: string; + } + + function createUser(data: UserData) { + /* ... */ + } # EVEN BETTER: Use builder pattern for complex construction + const user = UserBuilder + .email('[email protected]') + .password('secure123') + .name('Test User') + .address(address) + .build(); ``` ### 5. Feature Envy ```diff # BAD: Method that uses another object's data more than its own - class Order { - calculateDiscount(user) { - if (user.membershipLevel === 'gold') { + return this.total * 0.2; + } + if (user.accountAge > 365) { + return this.total * 0.1; + } + return 0; + } + } # GOOD: Move logic to the object that owns the data + class User { + getDiscountRate(orderTotal) { + if (this.membershipLevel === 'gold') return 0.2; + if (this.accountAge > 365) return 0.1; + return 0; + } + } + + class Order { + calculateDiscount(user) { + return this.total * user.getDiscountRate(this.total); + } + } ``` ### 6. Primitive Obsession ```diff # BAD: Using primitives for domain concepts - function sendEmail(to, subject, body) { /* ... */ } - sendEmail('[email protected]', 'Hello', '...'); - function createPhone(country, number) { - return `${country}-${number}`; - } # GOOD: Use domain types + class Email { + private constructor(public readonly value: string) { + if (!Email.isValid(value)) throw new Error('Invalid email'); + } + static create(value: string) { return new Email(value); } + static isValid(email: string) { return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email); } + } + + class PhoneNumber { + constructor( + public readonly country: string, + public readonly number: string + ) { + if (!PhoneNumber.isValid(country, number)) throw new Error('Invalid phone'); + } + toString() { return `${this.country}-${this.number}`; } + static isValid(country: string, number: string) { /* ... */ } + } + + // Usage + const email = Email.create('[email protected]'); + const phone = new PhoneNumber('1', '555-1234'); ``` ### 7. Magic Numbers/Strings ```diff # BAD: Unexplained values - if (user.status === 2) { /* ... */ } - const discount = total * 0.15; - setTimeout(callback, 86400000); # GOOD: Named constants + const UserStatus = { + ACTIVE: 1, + INACTIVE: 2, + SUSPENDED: 3 + } as const; + + const DISCOUNT_RATES = { + STANDARD: 0.1, + PREMIUM: 0.15, + VIP: 0.2 + } as const; + + const ONE_DAY_MS = 24 * 60 * 60 * 1000; + + if (user.status === UserStatus.INACTIVE) { /* ... */ } + const discount = total * DISCOUNT_RATES.PREMIUM; + setTimeout(callback, ONE_DAY_MS); ``` ### 8. Nested Conditionals ```diff # BAD: Arrow code - function process(order) { - if (order) { - if (order.user) { - if (order.user.isActive) { - if (order.total > 0) { - return processOrder(order); + } else { + return { error: 'Invalid total' }; + } + } else { + return { error: 'User inactive' }; + } + } else { + return { error: 'No user' }; + } + } else { + return { error: 'No order' }; + } + } # GOOD: Guard clauses / early returns + function process(order) { + if (!order) return { error: 'No order' }; + if (!order.user) return { error: 'No user' }; + if (!order.user.isActive) return { error: 'User inactive' }; + if (order.total <= 0) return { error: 'Invalid total' }; + return processOrder(order); + } # EVEN BETTER: Using Result type + function process(order): Result { + return Result.combine([ + validateOrderExists(order), + validateUserExists(order), + validateUserActive(order.user), + validateOrderTotal(order) + ]).flatMap(() => processOrder(order)); + } ``` ### 9. Dead Code ```diff # BAD: Unused code lingers - function oldImplementation() { /* ... */ } - const DEPRECATED_VALUE = 5; - import { unusedThing } from './somewhere'; - // Commented out code - // function oldCode() { /* ... */ } # GOOD: Remove it + // Delete unused functions, imports, and commented code + // If you need it again, git history has it ``` ### 10. Inappropriate Intimacy ```diff # BAD: One class reaches deep into another - class OrderProcessor { - process(order) { - order.user.profile.address.street; // Too intimate - order.repository.connection.config; // Breaking encapsulation + } + } # GOOD: Ask, don't tell + class OrderProcessor { + process(order) { + order.getShippingAddress(); // Order knows how to get it + order.save(); // Order knows how to save itself + } + } ``` --- ## Extract Method Refactoring ### Before and After ```diff # Before: One long function - function printReport(users) { - console.log('USER REPORT'); - console.log('============'); - console.log(''); - console.log(`Total users: ${users.length}`); - console.log(''); - console.log('ACTIVE USERS'); - console.log('------------'); - const active = users.filter(u => u.isActive); - active.forEach(u => { - console.log(`- ${u.name} (${u.email})`); - }); - console.log(''); - console.log(`Active: ${active.length}`); - console.log(''); - console.log('INACTIVE USERS'); - console.log('--------------'); - const inactive = users.filter(u => !u.isActive); - inactive.forEach(u => { - console.log(`- ${u.name} (${u.email})`); - }); - console.log(''); - console.log(`Inactive: ${inactive.length}`); - } # After: Extracted methods + function printReport(users) { + printHeader('USER REPORT'); + console.log(`Total users: ${users.length}\n`); + printUserSection('ACTIVE USERS', users.filter(u => u.isActive)); + printUserSection('INACTIVE USERS', users.filter(u => !u.isActive)); + } + + function printHeader(title) { + const line = '='.repeat(title.length); + console.log(title); + console.log(line); + console.log(''); + } + + function printUserSection(title, users) { + console.log(title); + console.log('-'.repeat(title.length)); + users.forEach(u => console.log(`- ${u.name} (${u.email})`)); + console.log(''); + console.log(`${title.split(' ')[0]}: ${users.length}`); + console.log(''); + } ``` --- ## Introducing Type Safety ### From Untyped to Typed ```diff # Before: No types - function calculateDiscount(user, total, membership, date) { - if (membership === 'gold' && date.getDay() === 5) { - return total * 0.25; - } - if (membership === 'gold') return total * 0.2; - return total * 0.1; - } # After: Full type safety + type Membership = 'bronze' | 'silver' | 'gold'; + + interface User { + id: string; + name: string; + membership: Membership; + } + + interface DiscountResult { + original: number; + discount: number; + final: number; + rate: number; + } + + function calculateDiscount( + user: User, + total: number, + date: Date = new Date() + ): DiscountResult { + if (total < 0) throw new Error('Total cannot be negative'); + + let rate = 0.1; // Default bronze + + if (user.membership === 'gold' && date.getDay() === 5) { + rate = 0.25; // Friday bonus for gold + } else if (user.membership === 'gold') { + rate = 0.2; + } else if (user.membership === 'silver') { + rate = 0.15; + } + + const discount = total * rate; + + return { + original: total, + discount, + final: total - discount, + rate + }; + } ``` --- ## Design Patterns for Refactoring ### Strategy Pattern ```diff # Before: Conditional logic - function calculateShipping(order, method) { - if (method === 'standard') { - return order.total > 50 ? 0 : 5.99; - } else if (method === 'express') { - return order.total > 100 ? 9.99 : 14.99; + } else if (method === 'overnight') { + return 29.99; + } + } # After: Strategy pattern + interface ShippingStrategy { + calculate(order: Order): number; + } + + class StandardShipping implements ShippingStrategy { + calculate(order: Order) { + return order.total > 50 ? 0 : 5.99; + } + } + + class ExpressShipping implements ShippingStrategy { + calculate(order: Order) { + return order.total > 100 ? 9.99 : 14.99; + } + } + + class OvernightShipping implements ShippingStrategy { + calculate(order: Order) { + return 29.99; + } + } + + function calculateShipping(order: Order, strategy: ShippingStrategy) { + return strategy.calculate(order); + } ``` ### Chain of Responsibility ```diff # Before: Nested validation - function validate(user) { - const errors = []; - if (!user.email) errors.push('Email required'); + else if (!isValidEmail(user.email)) errors.push('Invalid email'); + if (!user.name) errors.push('Name required'); + if (user.age < 18) errors.push('Must be 18+'); + if (user.country === 'blocked') errors.push('Country not supported'); + return errors; + } # After: Chain of responsibility + abstract class Validator { + abstract validate(user: User): string | null; + setNext(validator: Validator): Validator { + this.next = validator; + return validator; + } + validate(user: User): string | null { + const error = this.doValidate(user); + if (error) return error; + return this.next?.validate(user) ?? null; + } + } + + class EmailRequiredValidator extends Validator { + doValidate(user: User) { + return !user.email ? 'Email required' : null; + } + } + + class EmailFormatValidator extends Validator { + doValidate(user: User) { + return user.email && !isValidEmail(user.email) ? 'Invalid email' : null; + } + } + + // Build the chain + const validator = new EmailRequiredValidator() + .setNext(new EmailFormatValidator()) + .setNext(new NameRequiredValidator()) + .setNext(new AgeValidator()) + .setNext(new CountryValidator()); ``` --- ## Refactoring Steps ### Safe Refactoring Process ``` 1. PREPARE - Ensure tests exist (write them if missing) - Commit current state - Create feature branch 2. IDENTIFY - Find the code smell to address - Understand what the code does - Plan the refactoring 3. REFACTOR (small steps) - Make one small change - Run tests - Commit if tests pass - Repeat 4. VERIFY - All tests pass - Manual testing if needed - Performance unchanged or improved 5. CLEAN UP - Update comments - Update documentation - Final commit ``` --- ## Refactoring Checklist ### Code Quality - [ ] Functions are small (< 50 lines) - [ ] Functions do one thing - [ ] No duplicated code - [ ] Descriptive names (variables, functions, classes) - [ ] No magic numbers/strings - [ ] Dead code removed ### Structure - [ ] Related code is together - [ ] Clear module boundaries - [ ] Dependencies flow in one direction - [ ] No circular dependencies ### Type Safety - [ ] Types defined for all public APIs - [ ] No `any` types without justification - [ ] Nullable types explicitly marked ### Testing - [ ] Refactored code is tested - [ ] Tests cover edge cases - [ ] All tests pass --- ## Common Refactoring Operations | Operation | Description | | --------------------------------------------- | ------------------------------------- | | Extract Method | Turn code fragment into method | | Extract Class | Move behavior to new class | | Extract Interface | Create interface from implementation | | Inline Method | Move method body back to caller | | Inline Class | Move class behavior to caller | | Pull Up Method | Move method to superclass | | Push Down Method | Move method to subclass | | Rename Method/Variable | Improve clarity | | Introduce Parameter Object | Group related parameters | | Replace Conditional with Polymorphism | Use polymorphism instead of switch/if | | Replace Magic Number with Constant | Named constants | | Decompose Conditional | Break complex conditions | | Consolidate Conditional | Combine duplicate conditions | | Replace Nested Conditional with Guard Clauses | Early returns | | Introduce Null Object | Eliminate null checks | | Replace Type Code with Class/Enum | Strong typing | | Replace Inheritance with Delegation | Composition over inheritance |

相关技能

设计创意

Automation Workflows

设计和实施自动化工作流程,以节省时间和规模化操作作为独家. 用于识别重复任务实现自动化,构建跨工具的工作流程,设置触发器和行动,或优化现有自动化. 包括自动化机会识别,工作流程设计,工具选择(Zapier,Make,n8n),测试,和维护. 触发"自动","自动","工作流程自动…

设计创意

Ui Ux Pro Max

UI/UX设计智能及建筑抛光接口实施指导. 当用户要求UI设计,UX流量,信息架构,视觉风格方向,设计系统/托盘,组件规格,副本/显微镜,可访问性,或生成/critique/refine前端UI(HTML/CSS/JS,React,Next.js,Vue,Svelte,Tailw…

设计创意

Frontend Design

创建美丽现代UI的专家前端设计指南. 在构建起落架页面,仪表板,或任何用户界面时使用.

设计创意

N8n Workflow Automation

设计和输出 n8n 工作流程 JSON 有强力触发器, idempotency, 错误处理, 记录, 重试, 以及 人入"一站"审查队列. 当您需要可审计的自动化时使用.