程式碼編輯與重構

程式碼編輯和重構是開發者每天都在做的事。我以前改程式碼要開啟編輯器、找到位置、仔細修改、測試、再修改。用Claude Code之後,這些工作變得輕鬆多了。

這篇文章分享我用Claude Code進行程式碼編輯和重構的一些經驗。

單檔案編輯技巧

基礎編輯操作

最簡單的就是改單個檔案。舉個例子:

你有這樣一個使用者服務類:

# user_service.py (修改前)
class UserService:
    def __init__(self, db):
        self.db = db

    def get_user(self, user_id):
        return self.db.query(f"SELECT * FROM users WHERE id = {user_id}")

在Claude Code裡說:

给user_service.py加一个创建用户的方法,要包含参数验证和错误处理

Claude Code會分析現有程式碼結構,新增新方法:

# user_service.py (修改后)
class UserService:
    def __init__(self, db):
        self.db = db

    def get_user(self, user_id):
        """获取用户信息"""
        return self.db.query(f"SELECT * FROM users WHERE id = {user_id}")

    def create_user(self, username, email, password):
        """
        创建新用户

        Args:
            username: 用户名
            email: 邮箱地址
            password: 密码

        Returns:
            创建的用户ID

        Raises:
            ValueError: 当参数不合法时
            DatabaseError: 当数据库操作失败时
        """
        # 参数验证
        if not username or len(username) < 3:
            raise ValueError("用户名至少需要3个字符")

        if not email or '@' not in email:
            raise ValueError("邮箱格式不正确")

        if not password or len(password) < 6:
            raise ValueError("密码至少需要6个字符")

        # 创建用户
        try:
            user_id = self.db.execute(
                "INSERT INTO users (username, email, password) VALUES (?, ?, ?)",
                (username, email, password)
            )
            return user_id
        except Exception as e:
            raise DatabaseError(f"创建用户失败: {str(e)}")

精確定位編輯

檔案比較大的時候,可以直接說要改哪裡:

在UserService类的get_user方法里加个缓存功能

Claude Code會:

找到UserService類
定位get_user方法
在不影響其他程式碼的情況下新增快取

def get_user(self, user_id):
    """获取用户信息(带缓存)"""
    # 检查缓存
    cache_key = f"user:{user_id}"
    cached_user = self.cache.get(cache_key)
    if cached_user:
        return cached_user

    # 从数据库查询
    user = self.db.query(f"SELECT * FROM users WHERE id = {user_id}")

    # 更新缓存
    if user:
        self.cache.set(cache_key, user, ttl=300)

    return user

條件編輯

Claude Code可以根據程式碼的當前狀態做出智慧決策:

如果UserService还没有缓存功能,请添加Redis缓存支持

Claude Code會:

檢查是否已存在快取相關程式碼
如果不存在,新增Redis依賴和快取邏輯
如果已存在,告知你當前狀態

多檔案協同編輯

跨檔案重構

實際專案裡,重構往往會涉及多個檔案。Claude Code的強大之處在於它能理解檔案之間的依賴關係。

舉個例子:把使用者認證邏輯從控制器裡提取到一個獨立的服務類。

把auth_controller.py里的认证逻辑提取到一个新的AuthService类,
然后更新所有相关的导入和调用

Claude Code會:

分析當前程式碼結構

# auth_controller.py (修改前)
from flask import request, jsonify
import jwt
import bcrypt

class AuthController:
    def login(self):
        username = request.json.get('username')
        password = request.json.get('password')

        # 验证用户
        user = User.query.filter_by(username=username).first()
        if not user or not bcrypt.checkpw(password.encode(), user.password):
            return jsonify({'error': 'Invalid credentials'}), 401

        # 生成token
        token = jwt.encode({'user_id': user.id}, 'secret_key', algorithm='HS256')
        return jsonify({'token': token})

建立新的服務檔案

# auth_service.py (新建)
import jwt
import bcrypt
from datetime import datetime, timedelta
from models.user import User

class AuthService:
    """认证服务类"""

    def __init__(self, secret_key='secret_key'):
        self.secret_key = secret_key

    def authenticate(self, username, password):
        """
        验证用户凭据

        Args:
            username: 用户名
            password: 密码

        Returns:
            User对象或None
        """
        user = User.query.filter_by(username=username).first()
        if not user:
            return None

        if not bcrypt.checkpw(password.encode(), user.password):
            return None

        return user

    def generate_token(self, user_id, expires_in=3600):
        """
        生成JWT token

        Args:
            user_id: 用户ID
            expires_in: 过期时间(秒)

        Returns:
            JWT token字符串
        """
        payload = {
            'user_id': user_id,
            'exp': datetime.utcnow() + timedelta(seconds=expires_in)
        }
        return jwt.encode(payload, self.secret_key, algorithm='HS256')

    def verify_token(self, token):
        """
        验证JWT token

        Args:
            token: JWT token字符串

        Returns:
            解码后的payload或None
        """
        try:
            return jwt.decode(token, self.secret_key, algorithms=['HS256'])
        except jwt.ExpiredSignatureError:
            return None
        except jwt.InvalidTokenError:
            return None

更新控制器程式碼

# auth_controller.py (修改后)
from flask import request, jsonify
from services.auth_service import AuthService

class AuthController:
    def __init__(self):
        self.auth_service = AuthService()

    def login(self):
        username = request.json.get('username')
        password = request.json.get('password')

        # 使用AuthService验证
        user = self.auth_service.authenticate(username, password)
        if not user:
            return jsonify({'error': 'Invalid credentials'}), 401

        # 生成token
        token = self.auth_service.generate_token(user.id)
        return jsonify({'token': token})

更新其他相關檔案

Claude Code會自動檢查並更新其他使用AuthController的檔案:

# routes.py (自动更新)
from controllers.auth_controller import AuthController

auth_controller = AuthController()  # 确保正确初始化

@app.route('/login', methods=['POST'])
def login():
    return auth_controller.login()

批次檔案更新

當需要在多個檔案中進行相似的修改時:

请在所有React组件中将useState导入语句改为从'react'导入

Claude Code會:

搜尋所有React元件檔案
分析每個檔案的匯入語句
統一更新匯入方式
顯示修改摘要

✓ 更新了23个文件:
  - src/components/UserList.jsx
  - src/components/ProductCard.jsx
  - src/components/Header.jsx
  ... 等20个文件

所有useState导入已统一为:
  import { useState } from 'react';

程式碼重構的各種場景

重新命名重構

場景1: 重新命名變數

将UserService中的db变量重命名为database

Claude Code會智慧地重新命名所有引用:

# 修改前
class UserService:
    def __init__(self, db):
        self.db = db

    def get_user(self, user_id):
        return self.db.query(...)

    def create_user(self, data):
        return self.db.insert(...)

# 修改后
class UserService:
    def __init__(self, database):
        self.database = database

    def get_user(self, user_id):
        return self.database.query(...)

    def create_user(self, data):
        return self.database.insert(...)

場景2: 重新命名函式(跨檔案)

将calculate_price函数重命名为compute_total_price,
并更新所有调用该函数的地方

Claude Code會:

找到函式定義位置
搜尋所有呼叫點
全域性重新命名
更新相關的測試檔案

✓ 已重命名calculate_price为compute_total_price

修改的文件:
1. src/services/pricing.py (定义)
2. src/controllers/order_controller.py (调用)
3. src/utils/invoice.py (调用)
4. tests/test_pricing.py (测试)

所有引用已更新,共4个文件,8处修改。

提取函式

場景: 複雜函式拆分

# 修改前: 一个做太多事情的函数
def process_order(order_data):
    # 验证订单数据
    if not order_data.get('user_id'):
        raise ValueError("Missing user_id")
    if not order_data.get('items'):
        raise ValueError("No items in order")

    # 计算总价
    total = 0
    for item in order_data['items']:
        price = item['price'] * item['quantity']
        if item.get('discount'):
            price *= (1 - item['discount'])
        total += price

    # 检查库存
    for item in order_data['items']:
        stock = db.get_stock(item['product_id'])
        if stock < item['quantity']:
            raise ValueError(f"Insufficient stock for {item['product_id']}")

    # 创建订单
    order = {
        'user_id': order_data['user_id'],
        'items': order_data['items'],
        'total': total,
        'status': 'pending'
    }
    order_id = db.insert_order(order)

    # 发送通知
    send_email(order_data['user_id'], f"Order {order_id} created")

    return order_id

在Claude Code中:

请重构process_order函数,将其拆分为多个职责单一的函数

Claude Code的重構結果:

# 修改后: 职责清晰的多个函数
def validate_order_data(order_data):
    """验证订单数据"""
    if not order_data.get('user_id'):
        raise ValueError("Missing user_id")
    if not order_data.get('items'):
        raise ValueError("No items in order")

def calculate_order_total(items):
    """计算订单总价"""
    total = 0
    for item in items:
        price = calculate_item_price(item)
        total += price
    return total

def calculate_item_price(item):
    """计算单个商品价格(含折扣)"""
    price = item['price'] * item['quantity']
    if item.get('discount'):
        price *= (1 - item['discount'])
    return price

def check_stock_availability(items):
    """检查库存是否充足"""
    for item in items:
        stock = db.get_stock(item['product_id'])
        if stock < item['quantity']:
            raise ValueError(f"Insufficient stock for {item['product_id']}")

def create_order_record(user_id, items, total):
    """创建订单记录"""
    order = {
        'user_id': user_id,
        'items': items,
        'total': total,
        'status': 'pending'
    }
    return db.insert_order(order)

def notify_order_created(user_id, order_id):
    """发送订单创建通知"""
    send_email(user_id, f"Order {order_id} created")

def process_order(order_data):
    """
    处理订单流程

    该函数协调整个订单处理流程,包括验证、计算、库存检查和创建
    """
    # 验证订单数据
    validate_order_data(order_data)

    # 检查库存
    check_stock_availability(order_data['items'])

    # 计算总价
    total = calculate_order_total(order_data['items'])

    # 创建订单
    order_id = create_order_record(
        order_data['user_id'],
        order_data['items'],
        total
    )

    # 发送通知
    notify_order_created(order_data['user_id'], order_id)

    return order_id

提取類

場景: 從大類中提取職責

UserController太臃肿了,请将邮件相关的功能提取到EmailService类

# 修改前
class UserController:
    def register(self, data):
        user = self.create_user(data)
        self.send_welcome_email(user)
        return user

    def send_welcome_email(self, user):
        subject = "Welcome to Our Platform"
        body = f"Hello {user.name}, welcome!"
        self.smtp_send(user.email, subject, body)

    def send_reset_email(self, user):
        token = generate_token()
        subject = "Password Reset"
        body = f"Reset link: /reset?token={token}"
        self.smtp_send(user.email, subject, body)

    def smtp_send(self, to, subject, body):
        # SMTP发送逻辑
        pass

# 修改后 - 提取EmailService
class EmailService:
    """邮件服务类"""

    def __init__(self, smtp_config):
        self.smtp_config = smtp_config

    def send_welcome_email(self, user):
        """发送欢迎邮件"""
        subject = "Welcome to Our Platform"
        body = self._render_welcome_template(user)
        self._send(user.email, subject, body)

    def send_password_reset_email(self, user, token):
        """发送密码重置邮件"""
        subject = "Password Reset Request"
        body = self._render_reset_template(user, token)
        self._send(user.email, subject, body)

    def _render_welcome_template(self, user):
        """渲染欢迎邮件模板"""
        return f"Hello {user.name}, welcome to our platform!"

    def _render_reset_template(self, user, token):
        """渲染重置邮件模板"""
        return f"Reset your password: /reset?token={token}"

    def _send(self, to, subject, body):
        """发送邮件的底层方法"""
        # SMTP发送逻辑
        pass

class UserController:
    """用户控制器(重构后)"""

    def __init__(self, email_service):
        self.email_service = email_service

    def register(self, data):
        user = self.create_user(data)
        self.email_service.send_welcome_email(user)
        return user

移動程式碼

場景: 重組檔案結構

请将utils.py中的所有数据库相关函数移动到新的database_utils.py文件

Claude Code會:

識別資料庫相關函式
建立新檔案並移動程式碼
更新所有匯入語句
保留原檔案中的其他函式

✓ 已创建database_utils.py
✓ 移动了5个函数:
  - connect_db()
  - execute_query()
  - execute_batch()
  - close_connection()
  - get_connection_pool()

✓ 更新了12个文件的导入语句
✓ utils.py中保留了其他工具函数

程式碼格式化和美化

自動格式化

请格式化这个文件,使其符合PEP 8规范

# 格式化前
def calculate(x,y,z):
    result=x+y*z
    if result>100:
        return result
    else:
        return 0

# 格式化后
def calculate(x, y, z):
    """计算表达式 x + y * z"""
    result = x + y * z

    if result > 100:
        return result
    else:
        return 0

程式碼美化和最佳化

请优化这段代码的可读性和性能

// 优化前
function getUserData(users) {
    var result = [];
    for (var i = 0; i < users.length; i++) {
        if (users[i].age > 18) {
            result.push({
                name: users[i].name,
                email: users[i].email
            });
        }
    }
    return result;
}

// 优化后
function getAdultUserData(users) {
    /**
     * 过滤成年用户并提取姓名和邮箱
     * @param {Array} users - 用户列表
     * @returns {Array} 成年用户的姓名和邮箱数组
     */
    return users
        .filter(user => user.age > 18)
        .map(user => ({
            name: user.name,
            email: user.email
        }));
}

Claude Code的最佳化包括:

使用更具描述性的函式名
採用函數語言程式設計方法
新增JSDoc註釋
使用const/let替代var
使用箭頭函式

一致性格式化

请统一整个项目的代码风格,使用Airbnb JavaScript规范

Claude Code會:

分析專案中的所有JavaScript檔案
應用Airbnb規範
修復不一致的地方
生成修改報告

程式碼最佳化建議

效能最佳化

请分析并优化这段代码的性能

# 优化前: O(n²)复杂度
def find_duplicates(arr):
    duplicates = []
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            if arr[i] == arr[j] and arr[i] not in duplicates:
                duplicates.append(arr[i])
    return duplicates

# 优化后: O(n)复杂度
def find_duplicates(arr):
    """
    查找数组中的重复元素

    使用集合和计数器实现O(n)时间复杂度

    Args:
        arr: 输入数组

    Returns:
        包含所有重复元素的列表
    """
    from collections import Counter

    counts = Counter(arr)
    return [item for item, count in counts.items() if count > 1]

Claude Code的最佳化說明:

性能改进:
- 时间复杂度: O(n²) → O(n)
- 空间复杂度: O(n)
- 使用Counter进行一次遍历
- 避免了嵌套循环和重复检查

性能提升:
- 1000个元素: 500ms → 2ms
- 10000个元素: 50s → 20ms

程式碼質量建議

请审查这段代码并提供改进建议

// 原始代码
function processData(data) {
    var result = data.filter(x => x.status == 'active')
                    .map(x => x.value);
    if (result.length > 0) {
        var sum = 0;
        for (var i = 0; i < result.length; i++) {
            sum += result[i];
        }
        return sum / result.length;
    }
    return 0;
}

Claude Code的分析和改進:

/**
 * 计算活跃项的平均值
 *
 * @param {Array<{status: string, value: number}>} data - 数据项数组
 * @returns {number} 活跃项的平均值,如果没有活跃项则返回0
 *
 * @example
 * const data = [
 *   { status: 'active', value: 10 },
 *   { status: 'inactive', value: 20 },
 *   { status: 'active', value: 30 }
 * ];
 * calculateActiveAverage(data); // 返回 20
 */
function calculateActiveAverage(data) {
    // 使用严格相等比较
    const activeValues = data
        .filter(item => item.status === 'active')
        .map(item => item.value);

    // 提前返回,避免不必要的计算
    if (activeValues.length === 0) {
        return 0;
    }

    // 使用reduce计算总和,更函数式
    const sum = activeValues.reduce((acc, value) => acc + value, 0);

    return sum / activeValues.length;
}

改進說明:

1. 命名改进:
   ✓ 函数名更具描述性
   ✓ 变量名清晰明了

2. 代码质量:
   ✓ 使用严格相等(===)
   ✓ 使用const/let替代var
   ✓ 使用reduce替代for循环

3. 文档:
   ✓ 添加完整的JSDoc
   ✓ 包含使用示例

4. 逻辑优化:
   ✓ 提前返回,避免不必要计算
   ✓ 更函数式的编程风格

處理複雜重構任務

架構級重構

場景: 從MVC遷移到Clean Architecture

请将这个Express应用重构为Clean Architecture架构,
包括Entity、UseCase、Controller和Repository层

Claude Code會分步驟進行:

第1步: 建立目錄結構

✓ 创建架构目录:
  src/
    entities/          # 业务实体
    usecases/          # 用例层
    adapters/
      controllers/     # 控制器
      repositories/    # 数据访问
    frameworks/        # 框架和驱动

第2步: 提取業務實體

// src/entities/User.js
class User {
    constructor(id, name, email, password) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.password = password;
    }

    isValid() {
        return this.name &&
               this.email &&
               this.email.includes('@') &&
               this.password &&
               this.password.length >= 6;
    }

    static create(data) {
        return new User(
            null,
            data.name,
            data.email,
            data.password
        );
    }
}

module.exports = User;

第3步: 建立用例

// src/usecases/CreateUser.js
class CreateUser {
    constructor(userRepository, passwordHasher, emailService) {
        this.userRepository = userRepository;
        this.passwordHasher = passwordHasher;
        this.emailService = emailService;
    }

    async execute(userData) {
        // 创建实体
        const user = User.create(userData);

        // 验证
        if (!user.isValid()) {
            throw new Error('Invalid user data');
        }

        // 检查邮箱是否已存在
        const existingUser = await this.userRepository.findByEmail(user.email);
        if (existingUser) {
            throw new Error('Email already exists');
        }

        // 加密密码
        user.password = await this.passwordHasher.hash(user.password);

        // 保存用户
        const savedUser = await this.userRepository.save(user);

        // 发送欢迎邮件
        await this.emailService.sendWelcome(savedUser);

        return savedUser;
    }
}

module.exports = CreateUser;

第4步: 重構控制器

// src/adapters/controllers/UserController.js
class UserController {
    constructor(createUserUseCase) {
        this.createUserUseCase = createUserUseCase;
    }

    async register(req, res) {
        try {
            const user = await this.createUserUseCase.execute(req.body);
            res.status(201).json({
                id: user.id,
                name: user.name,
                email: user.email
            });
        } catch (error) {
            if (error.message === 'Email already exists') {
                res.status(409).json({ error: error.message });
            } else {
                res.status(400).json({ error: error.message });
            }
        }
    }
}

module.exports = UserController;

第5步: 更新依賴注入

// src/frameworks/di-container.js
const CreateUser = require('../usecases/CreateUser');
const UserController = require('../adapters/controllers/UserController');
const UserRepository = require('../adapters/repositories/UserRepository');
const BcryptHasher = require('./BcryptHasher');
const EmailService = require('./EmailService');

class DIContainer {
    constructor() {
        this.services = {};
    }

    getUserController() {
        if (!this.services.userController) {
            const repository = new UserRepository();
            const hasher = new BcryptHasher();
            const emailService = new EmailService();
            const createUserUseCase = new CreateUser(repository, hasher, emailService);
            this.services.userController = new UserController(createUserUseCase);
        }
        return this.services.userController;
    }
}

module.exports = new DIContainer();

漸進式重構

對於大型重構,Claude Code支援漸進式方法:

让我们分阶段重构这个应用:
第一阶段: 提取所有数据库操作到Repository层
第二阶段: 创建Service层
第三阶段: 实现依赖注入
第四阶段: 添加单元测试

现在开始第一阶段

Claude Code會:

記住整體重構計劃
專注於當前階段
在完成後詢問是否繼續下一階段
保持各階段的程式碼相容性

重構前的安全檢查

依賴分析

请分析修改UserService会影响哪些文件

Claude Code會進行全面分析:

依赖分析报告:

1. 直接引用 (3个文件):
   - src/controllers/UserController.js (导入和实例化)
   - src/routes/user.routes.js (通过控制器使用)
   - tests/unit/user.service.test.js (单元测试)

2. 间接影响 (5个文件):
   - src/controllers/AuthController.js (使用UserService.findById)
   - src/middleware/auth.js (依赖用户验证逻辑)
   - src/services/OrderService.js (获取用户信息)
   - tests/integration/auth.test.js (集成测试)
   - tests/e2e/user-flow.test.js (E2E测试)

3. 风险评估:
   ⚠️ 中风险: 修改可能影响8个文件
   ⚠️ 建议先运行测试确保无破坏性更改
   ✓ 所有依赖都是通过接口调用,耦合度低

4. 建议:
   1. 修改前创建Git分支
   2. 运行现有测试套件
   3. 逐步修改并验证
   4. 更新相关测试

測試覆蓋檢查

在重构前,请确保UserService有足够的测试覆盖

Claude Code會:

分析現有測試
識別未覆蓋的程式碼路徑
建議新增缺失的測試

测试覆盖分析:

当前覆盖率: 67%

✓ 已覆盖:
  - 用户创建基本流程
  - 邮箱重复检查
  - 基本验证逻辑

❌ 未覆盖:
  - 密码加密失败场景
  - 数据库连接失败处理
  - 并发创建用户的竞态条件

建议: 在重构前添加以下测试...

向後相容性檢查

请确保重构后的API保持向后兼容

Claude Code會設計相容方案:

// 重构策略: 保持旧接口,内部使用新实现
class UserService {
    // 新方法: 推荐使用
    async createUser(userData) {
        return await this.userRepository.create(userData);
    }

    // 旧方法: 保持向后兼容
    async create(data) {
        console.warn('UserService.create() is deprecated. Use createUser() instead.');
        return await this.createUser(data);
    }
}

實際重構案例

案例1: 消除程式碼重複

初始狀態: 多個控制器有重複的驗證邏輯

// UserController.js
class UserController {
    async create(req, res) {
        // 重复的验证逻辑
        if (!req.body.name) {
            return res.status(400).json({ error: 'Name is required' });
        }
        if (!req.body.email) {
            return res.status(400).json({ error: 'Email is required' });
        }
        if (!req.body.email.includes('@')) {
            return res.status(400).json({ error: 'Invalid email' });
        }
        // ... 业务逻辑
    }
}

// ProductController.js
class ProductController {
    async create(req, res) {
        // 类似的重复验证逻辑
        if (!req.body.name) {
            return res.status(400).json({ error: 'Name is required' });
        }
        if (!req.body.price) {
            return res.status(400).json({ error: 'Price is required' });
        }
        // ... 业务逻辑
    }
}

重構請求:

这些控制器有大量重复的验证逻辑,请创建一个统一的验证系统

Claude Code的重構:

// src/validators/ValidationRules.js
class ValidationRules {
    static required(fieldName) {
        return (value) => {
            if (!value) {
                throw new Error(`${fieldName} is required`);
            }
            return value;
        };
    }

    static email(fieldName) {
        return (value) => {
            if (!value.includes('@')) {
                throw new Error(`${fieldName} must be a valid email`);
            }
            return value;
        };
    }

    static minLength(fieldName, length) {
        return (value) => {
            if (value.length < length) {
                throw new Error(`${fieldName} must be at least ${length} characters`);
            }
            return value;
        };
    }

    static number(fieldName) {
        return (value) => {
            if (isNaN(value)) {
                throw new Error(`${fieldName} must be a number`);
            }
            return Number(value);
        };
    }
}

module.exports = ValidationRules;

// src/validators/Validator.js
class Validator {
    constructor(schema) {
        this.schema = schema;
    }

    validate(data) {
        const errors = [];
        const validated = {};

        for (const [field, rules] of Object.entries(this.schema)) {
            try {
                let value = data[field];
                for (const rule of rules) {
                    value = rule(value);
                }
                validated[field] = value;
            } catch (error) {
                errors.push(error.message);
            }
        }

        if (errors.length > 0) {
            throw new ValidationError(errors);
        }

        return validated;
    }
}

module.exports = Validator;

// src/validators/schemas/userSchema.js
const { ValidationRules: R } = require('../ValidationRules');

const userSchema = {
    name: [R.required('Name'), R.minLength('Name', 2)],
    email: [R.required('Email'), R.email('Email')],
    password: [R.required('Password'), R.minLength('Password', 6)]
};

module.exports = userSchema;

// UserController.js (重构后)
const Validator = require('../validators/Validator');
const userSchema = require('../validators/schemas/userSchema');

class UserController {
    constructor() {
        this.validator = new Validator(userSchema);
    }

    async create(req, res) {
        try {
            const validatedData = this.validator.validate(req.body);
            const user = await this.userService.create(validatedData);
            res.status(201).json(user);
        } catch (error) {
            if (error instanceof ValidationError) {
                res.status(400).json({ errors: error.errors });
            } else {
                res.status(500).json({ error: 'Internal server error' });
            }
        }
    }
}

重構成果:

消除了所有重複的驗證程式碼
建立了可複用的驗證系統
更容易新增新的驗證規則
驗證邏輯統一管理

案例2: API響應格式統一

問題: API響應格式不一致

// 不同的控制器返回不同的格式
// UserController
return res.json({ user: data });

// ProductController
return res.json({ success: true, data: products });

// OrderController
return res.json({ result: order, message: 'Order created' });

重構請求:

请统一所有API的响应格式,使用标准的RESTful格式

Claude Code的方案:

// src/utils/ApiResponse.js
class ApiResponse {
    static success(data, message = null, meta = null) {
        const response = {
            success: true,
            data
        };

        if (message) response.message = message;
        if (meta) response.meta = meta;

        return response;
    }

    static error(message, errors = null, code = null) {
        const response = {
            success: false,
            message
        };

        if (errors) response.errors = errors;
        if (code) response.code = code;

        return response;
    }

    static paginated(data, page, limit, total) {
        return this.success(data, null, {
            pagination: {
                page,
                limit,
                total,
                totalPages: Math.ceil(total / limit)
            }
        });
    }
}

module.exports = ApiResponse;

// 中间件: src/middleware/responseHandler.js
const ApiResponse = require('../utils/ApiResponse');

function responseHandler(req, res, next) {
    // 成功响应
    res.success = (data, message, meta) => {
        return res.json(ApiResponse.success(data, message, meta));
    };

    // 错误响应
    res.error = (message, errors, code) => {
        const statusCode = code || 500;
        return res.status(statusCode).json(ApiResponse.error(message, errors, code));
    };

    // 分页响应
    res.paginated = (data, page, limit, total) => {
        return res.json(ApiResponse.paginated(data, page, limit, total));
    };

    next();
}

module.exports = responseHandler;

// 更新后的控制器
class UserController {
    async list(req, res) {
        const { page = 1, limit = 10 } = req.query;
        const { users, total } = await this.userService.findAll(page, limit);
        return res.paginated(users, page, limit, total);
    }

    async create(req, res) {
        const user = await this.userService.create(req.body);
        return res.success(user, 'User created successfully');
    }

    async update(req, res) {
        try {
            const user = await this.userService.update(req.params.id, req.body);
            return res.success(user, 'User updated');
        } catch (error) {
            return res.error(error.message, null, 400);
        }
    }
}

重構的黃金法則

1. 小步快走

❌ 錯誤方式:

把整个项目重构为微服务架构

✅ 正確方式:

第一步: 提取用户服务的业务逻辑到独立模块
第二步: 为该模块添加完整测试
第三步: 创建独立的API网关
第四步: 逐步迁移其他服务

2. 保持測試先行

在重构UserService之前,请先确保有完整的测试覆盖

Claude Code會:

分析現有測試覆蓋率
補充缺失的測試
執行重構
驗證所有測試透過

3. 保持可回滾

每次重構前,Claude Code會提醒:

建议:
创建新的Git分支: git checkout -b refactor/user-service
提交当前更改
分步骤进行重构
每个步骤后都提交,方便回滚

常見陷阱和解決方案

陷阱1: 過度重構

❌ 問題:

将每个函数都拆分成多个小函数,导致代码难以理解

✅ 解決:

请帮我评估这段代码是否需要重构,如果已经足够清晰就保持不变

Claude Code會給出客觀評估:

分析结果:
该函数长度: 15行
圈复杂度: 2
职责: 单一
可读性: 良好

建议: 该函数无需重构,已经足够简洁和清晰。

陷阱2: 破壞向後相容性

❌ 問題:

// 直接修改公共API
function getUser(id) { ... }
// 改为
function fetchUserById(id) { ... }  // 破坏了现有调用

✅ 解決:

重构时请保持API向后兼容,可以添加新方法但保留旧方法

陷阱3: 忽略效能影響

请分析这个重构对性能的影响

Claude Code會提供效能對比:

性能影响分析:

原始实现:
- 时间复杂度: O(n)
- 空间复杂度: O(1)
- 平均响应时间: 5ms

重构后:
- 时间复杂度: O(n log n)
- 空间复杂度: O(n)
- 平均响应时间: 15ms

⚠️ 警告: 重构会降低性能
建议: 考虑使用索引或缓存来优化

總結

Claude Code的程式碼編輯和重構能力讓你能夠:

✅ 快速編輯: 精確定位和修改程式碼 ✅ 安全重構: 分析依賴,避免破壞性更改 ✅ 智慧最佳化: 提供效能和質量改進建議 ✅ 保持質量: 自動格式化和應用最佳實踐 ✅ 大規模修改: 跨檔案、跨模組的複雜重構

最佳實踐

編輯程式碼時:

說明白要改什麼
給足夠的上下文資訊
複雜修改分步驟做

重構程式碼時:

記住:

好程式碼是重構出來的,不是一次寫成的
測試是重構的安全網
保持程式碼簡潔,但別過度最佳化
效能最佳化要基於實際測量,不是臆測

下一步

掌握了程式碼編輯和重構後,繼續探索:

Agent模式 - 讓Claude Code自主完成複雜任務
測試與除錯 - 自動生成測試和除錯程式碼
大規模重構案例 - 18000行程式碼重構實戰

參考資源

重構: 改善既有程式碼的設計 - Martin Fowler經典著作
Clean Code - Robert C. Martin
Claude Code最佳實踐

單檔案編輯技巧​

基礎編輯操作​

精確定位編輯​

條件編輯​

多檔案協同編輯​

跨檔案重構​

批次檔案更新​

程式碼重構的各種場景​

重新命名重構​

提取函式​

提取類​

移動程式碼​

程式碼格式化和美化​

自動格式化​

程式碼美化和最佳化​

一致性格式化​

程式碼最佳化建議​

效能最佳化​

程式碼質量建議​

處理複雜重構任務​

架構級重構​

漸進式重構​

重構前的安全檢查​

依賴分析​

測試覆蓋檢查​

向後相容性檢查​

實際重構案例​

案例1: 消除程式碼重複​

案例2: API響應格式統一​

重構的黃金法則​

1. 小步快走​

2. 保持測試先行​

3. 保持可回滾​

常見陷阱和解決方案​

陷阱1: 過度重構​

陷阱2: 破壞向後相容性​

陷阱3: 忽略效能影響​

總結​

最佳實踐​

下一步​

參考資源​

單檔案編輯技巧

基礎編輯操作

精確定位編輯

條件編輯

多檔案協同編輯

跨檔案重構

批次檔案更新

程式碼重構的各種場景

重新命名重構

提取函式

提取類

移動程式碼

程式碼格式化和美化

自動格式化

程式碼美化和最佳化

一致性格式化

程式碼最佳化建議

效能最佳化

程式碼質量建議

處理複雜重構任務

架構級重構

漸進式重構

重構前的安全檢查

依賴分析

測試覆蓋檢查

向後相容性檢查

實際重構案例

案例1: 消除程式碼重複

案例2: API響應格式統一

重構的黃金法則

1. 小步快走

2. 保持測試先行

3. 保持可回滾

常見陷阱和解決方案

陷阱1: 過度重構

陷阱2: 破壞向後相容性

陷阱3: 忽略效能影響

總結

最佳實踐

下一步

參考資源