Skip to content

AI 代码重构指南 ​

IfAI 的 AI 重构功能帮助您通过智能建议和自动转换来提高代码质量、可维护性和性能。

什么是 AI 重构? ​

AI 驱动的重构使用机器学习来:

  • 检测代码异味 - 识别有问题的代码模式
  • 建议改进 - 提出更好的实现
  • 应用转换 - 自动重构代码
  • 确保正确性 - 在改进结构的同时保持行为

代码异味检测 ​

IfAI 自动检测常见的代码异味:

异味类型描述示例
长函数超过 50 行的函数200 行的 processUserData()
代码重复重复的逻辑在 5 个地方的相同验证
复杂条件嵌套的 if/else5+ 层嵌套
魔法数字未命名的常量if (x > 42)
命名不一致混合约定getUserInfo() 和 get_user_data()

触发检测 ​

Cmd+Shift+P > "AI: 分析代码质量"

或选择代码并使用斜杠命令:

/refactor this function

重构工作流程 ​

AI 重构演示

步骤 1:分析代码 ​

选择代码并要求 AI 分析:

分析此函数的代码异味和改进机会

AI 提供详细分析:

  • 复杂度评分
  • 识别的问题
  • 改进建议

步骤 2:审查建议 ​

AI 显示具体的重构建议:

┌─────────────────────────────────────────────────────────┐
│  重构建议                                                │
├─────────────────────────────────────────────────────────┤
│  🔴 高优先级                                             │
│  • 将验证提取到单独的函数                                │
│  • 用常量替换魔法数字                                    │
│  • 为边缘情况添加错误处理                                │
│                                                         │
│  🟡 中优先级                                             │
│  • 拆分为更小的函数                                      │
│  • 使用提前返回模式                                      │
│  • 添加 JSDoc 注释                                      │
└─────────────────────────────────────────────────────────┘

步骤 3:预览更改 ​

审查前后对比:

typescript
// 之前
function processUser(user) {
  if (user && user.age > 18 && user.hasPermission) {
    // 50 行逻辑
  }
  return result;
}

// 之后
function processUser(user) {
  if (!isValidUser(user)) {
    return null;
  }

  return processValidUser(user);
}

步骤 4:应用重构 ​

选择性应用:

  • 接受所有建议
  • 选择特定改进
  • 应用前修改建议

重构类型 ​

提取方法 ​

分解长函数:

将用户验证逻辑提取到单独的函数

之前:

typescript
function login(username, password) {
  // 20 行验证
  // 10 行认证
  // 15 行会话设置
}

之后:

typescript
function login(username, password) {
  validateCredentials(username, password);
  const user = authenticate(username, password);
  setupSession(user);
}

提取类 ​

将相关函数组合成一个类:

将与用户相关的函数提取到 UserService 类中

重命名符号 ​

一致的命名:

在整个文件中将 'usr' 重命名为 'user'

内联变量 ​

删除不必要的变量:

内联 'tempResult' 变量

简化条件 ​

减少嵌套:

使用守卫子句简化这个嵌套的 if 语句

之前:

typescript
function process(data) {
  if (data) {
    if (data.items) {
      if (data.items.length > 0) {
        // 处理
      }
    }
  }
}

之后:

typescript
function process(data) {
  if (!data?.items?.length) return;
  // 处理
}

最佳实践 ​

增量重构 ​

进行小而专注的更改:

✅ 好的: "将错误处理提取到单独的函数"
❌ 不好的: "重构整个认证模块"

测试覆盖 ​

重构前始终有测试:

  1. 为当前行为编写测试
  2. 重构
  3. 验证测试仍然通过
bash
# 重构之前
npm test

# 重构之后
npm test  # 所有测试应该通过

版本控制 ​

在主要重构之前提交:

bash
git commit -am "重构之前"
# 应用重构
git diff  # 审查更改
git commit -am "重构之后"

仔细审查 ​

AI 建议是推荐,不是命令:

  • 审查每个更改
  • 理解为什么建议这样做
  • 只接受能改善您代码的内容

示例 ​

示例 1:DRY(不要重复自己) ​

之前:

typescript
function validateEmail(email) {
  if (!email || !email.includes('@')) return false;
  if (!email.includes('.')) return false;
  return true;
}

function validateUserInput(input) {
  if (!input || !input.includes('@')) return false;
  if (!input.includes('.')) return false;
  return true;
}

之后:

typescript
function isValidEmail(value) {
  return value?.includes('@') && value?.includes('.');
}

function validateEmail(email) {
  return isValidEmail(email);
}

function validateUserInput(input) {
  return isValidEmail(input);
}

示例 2:守卫子句 ​

之前:

typescript
function getUser(id) {
  if (id) {
    const user = db.find(id);
    if (user) {
      if (user.active) {
        return user;
      } else {
        return null;
      }
    } else {
      return null;
    }
  } else {
    return null;
  }
}

之后:

typescript
function getUser(id) {
  if (!id) return null;
  const user = db.find(id);
  if (!user?.active) return null;
  return user;
}

示例 3:魔法数字 ​

之前:

typescript
function calculateDiscount(price) {
  if (price > 100) {
    return price * 0.9;
  } else if (price > 50) {
    return price * 0.95;
  }
  return price;
}

之后:

typescript
const DISCOUNT_HIGH = 0.1;  // 10%
const DISCOUNT_MEDIUM = 0.05;  // 5%
const PRICE_HIGH = 100;
const PRICE_MEDIUM = 50;

function calculateDiscount(price) {
  if (price > PRICE_HIGH) {
    return price * (1 - DISCOUNT_HIGH);
  }
  if (price > PRICE_MEDIUM) {
    return price * (1 - DISCOUNT_MEDIUM);
  }
  return price;
}

高级用法 ​

批量重构 ​

重构多个文件:

重构所有服务文件以使用 async/await 而不是 promises

基于模式的重构 ​

应用一致的模式:

对所有数据访问函数应用 Repository 模式

自定义规则 ​

定义重构规则:

重构时始终:
- 添加 TypeScript 类型
- 包含错误处理
- 添加 JSDoc 注释
- 默认使用 const

故障排查 ​

"未找到建议" ​

原因:

  • 代码结构良好
  • 选择太小/太大
  • 语言不完全支持

解决方案:

  1. 尝试更大的选择
  2. 在请求中更具体
  3. 手动描述您想要的改进

"重构破坏了测试" ​

解决方案:

  1. 仔细审查差异
  2. 检查逻辑错误
  3. 恢复并尝试不同的方法
  4. 如果 AI 更改了行为,请报告问题

"建议太多" ​

解决方案:

  1. 首先专注于高优先级项目
  2. 增量应用更改
  3. 在请求中更具体

学习笔记 ​

AI 代码重构学习笔记

下一步 ​

基于 MIT 许可发布