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 许可发布