用 Prompt 写出更可读的代码

函数职责要单一

Java 中一个方法里做了读取、计算、输出三件事，后续稍微调整需求就得折腾半天：

// 原来的代码
public void processData(String filePath) {
    // 1. 读取文件
    List<String> data = new ArrayList<>();
    try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
        String line;
        while ((line = br.readLine()) != null) {
            data.add(line);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    // 2. 计算平均值
    double sum = 0;
    for (String s : data) {
        sum += Double.parseDouble(s);
    }
    double avg = sum / data.size();
    // 3. 输出结果
    System.out.println("平均值：" + avg);
}

拆成三个各司其职的方法后，逻辑分层清晰，也更容易单独测试：

// 重构后
public class DataProcessor {
    public List<Double> readDataFromFile(String filePath) throws IOException {
        List<Double> data = new ArrayList<>();
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                data.add(Double.parseDouble(line));
            }
        }
        return data;
    }

    public double calculateAverage(List<Double> data) {
        double sum = 0;
        for (double num : data) {
            sum += num;
        }
        return sum / data.size();
    }

    public void printResult(double average) {
        System.out.println("数据平均值：" + average);
    }
}

别嵌套太深

JavaScript 里那个经典的折扣计算，四层 if 看着就累：

// 原来的代码
function getDiscount(price, userType, isNewUser, hasCoupon) {
    let discount = 0;
    if (userType === "VIP") {
        if (isNewUser) {
            discount = 0.8;
            if (hasCoupon) {
                discount = 0.7;
            }
        } else {
            if (hasCoupon) {
                discount = 0.85;
            } else {
                discount = 0.9;
            }
        }
    }
    return price * discount;
}

用对象映射替代嵌套，规则一目了然，以后加逻辑也简单：

// 重构后
function getDiscount(price, userType, isNewUser, hasCoupon) {
    const discountRules = {
        VIP: { new: { coupon: 0.7, noCoupon: 0.8 }, old: { coupon: 0.85, noCoupon: 0.9 } },
        normal: { new: { coupon: 0.95, noCoupon: 1.0 }, old: { coupon: 0.98, noCoupon: 1.0 } }
    };
    const userTier = isNewUser ? "new" : "old";
    const couponStatus = hasCoupon ? "coupon" : "noCoupon";
    const discount = discountRules[userType]?.[userTier]?.[couponStatus] || 1.0;
    return price * discount;
}

注释说'为什么'

没注释的代码像天书，注释只写'是什么'也用处不大。看这个 Python 日期格式化函数：

# 原来的代码
def format_date(date_str):
    parts = date_str.split("-")
    if len(parts) == 3:
        return f"{parts[2]}/{parts[1]}/{parts[0]}"
    else:
        return "Invalid"

加上文档字符串和关键步骤说明后，别人一眼就知道它想干什么：

# 重构后
def format_date(date_str: str) -> str:
    """将 ISO 日期格式（YYYY-MM-DD）转换为日/月/年格式（DD/MM/YYYY）
    参数：
        date_str: str - 输入的日期字符串，需符合 ISO 格式（如"2024-05-20"）
    返回：
        str - 转换后的日期字符串，若格式无效则返回"Invalid Date"
    说明：
        1. 先按"-"分割字符串，判断是否为 3 个部分（年/月/日）
        2. 若格式正确，重组为 DD/MM/YYYY；否则返回无效提示
    """
    parts = date_str.split("-")
    if len(parts) == 3 and all(part.isdigit() for part in parts):
        return f"{parts[2]}/{parts[1]}/{parts[0]}"
    else:
        return "Invalid Date"

消灭重复代码

Java 里对每个商品都写一套计算逻辑，硬编码单价，改价格就得改好几个地方：

// 原来的代码
public class OrderCalculator {
    public double calculateProductA(double quantity) {
        return quantity * 99.9;
    }
    public double calculateProductB(double quantity) {
        return quantity * 199.9;
    }
}

抽出公共方法和常量，以后维护就简单多了：

// 重构后
public class OrderCalculator {
    private static final double PRODUCT_A_PRICE = 99.9;
    private static final double PRODUCT_B_PRICE = 199.9;

    private double calculateProductTotal(double quantity, double price) {
        return quantity * price;
    }

    public double calculateProductA(double quantity) {
        return calculateProductTotal(quantity, PRODUCT_A_PRICE);
    }

    public double calculateProductB(double quantity) {
        return calculateProductTotal(quantity, PRODUCT_B_PRICE);
    }
}

怎么让模型帮你重构

有了清晰的标准，接下来就是让模型动手。核心是把话说清楚：告诉它你是谁（角色）、要干什么（任务）、有什么限制（约束）。根据复杂度，我一般分两个粒度来写 Prompt。

基础版：针对单个函数或小片段

对于那种一眼能看出毛病的独立函数，Prompt 不需要太复杂，直接给代码和要求就能出结果。

模板：

指令：作为一名资深 [语言] 开发工程师，请帮我重构以下代码，提升其可读性。 原始代码：[粘贴代码] 重构要求：

1. 优化命名，遵循 [语言] 命名规范
2. 简化逻辑，减少冗余判断和嵌套
3. 补充必要注释（函数文档 + 关键逻辑注释）
4. 输出格式：先给出重构后的完整代码，再逐点说明修改了哪里、为什么

实战：就拿前面 Python 那个模糊函数开刀，把代码和指令一起丢给模型：

指令：作为一名资深 Python 开发工程师，请帮我重构以下代码，提升其可读性。
原始代码：
def f1(d, k):
    res = []
    for i in d:
        if i == k:
            v = d[i]
            if v > 10:
                res.append(v)
    return res
重构要求：
1. 优化命名，遵循 Python 蛇形命名法
2. 简化逻辑，可使用列表推导式
3. 补充文档字符串和关键注释
4. 输出格式：先给出完整代码，再分点说明重构理由

模型返回的结果和之前手动改的版本几乎一致：

def filter_dict_values_by_key(dict_data: dict, target_key: str) -> list:
    """根据指定键筛选字典中大于 10 的值，并返回结果列表
    参数：
        dict_data: dict - 输入的字典，键为字符串类型，值为数字类型
        target_key: str - 需要筛选的目标键
    返回：
        list - 符合条件的值组成的列表（仅包含 target_key 对应的值且该值>10）
    """
    return [value for key, value in dict_data.items() if key == target_key and value > 10]

# 重构点及原因说明：
# 1. 函数名改为 filter_dict_values_by_key，直接体现功能
# 2. 参数名从 d、k 改为 dict_data、target_key，消除歧义
# 3. 用列表推导式替代双层循环，逻辑更紧凑
# 4. 添加类型注解和完整文档字符串，方便阅读和 IDE 提示

进阶版：面向模块和行业规范

如果是一整个类或者模块，还涉及 Spring Boot、Django 这类框架，基础 Prompt 就不够了。你得补充上下文：模块功能、技术栈、依赖关系，以及要遵守的规范（比如 Google Java 规范）。这样模型才能给出贴合实际项目、可以直接合入仓库的方案。

因为内容展开会很长，这里就不把完整模板和例子全列出来了。关键思路是和模型做'需求沟通'——角色、背景、约束缺一不可。实际用的时候，可以先用简单 Prompt 试一下，再逐步补充细节，直到输出满意为止。

几点注意

用 Prompt 重构省时间，但也不是万能的，我踩过一些坑：

• 过度设计：模型偶尔会把简单逻辑抽象成分层分层的结构，看着高级，反而增加了理解成本。这时候要在 Prompt 里加一句'保持简洁，不引入没必要的新类或模式'。
• 功能不一致：重构后逻辑可能悄悄变了，尤其是边界条件。所以一定要有测试，哪怕只是几个单测用例。
• 注释过时：模型生成注释后，如果后续手动改了代码，要记得同步注释，否则误导性更大。

说到底，Prompt 只是工具，可读性最终取决于人的判断。对于关键业务代码，还是得多看一眼。