函数级别的重构：提取函数、内联函数、引入参数对象、分解条件表达式

函数是代码的基本单元。我见过太多遗留系统，一个函数动辄几百行，缩进七八层，看着就让人头疼。说实话，函数级别的重构是所有重构里性价比最高的——改得少，见效快，风险低。

今天咱们就聊聊四个最实用的函数重构手法：提取函数、内联函数、引入参数对象、分解条件表达式。这些手法我在实际项目中反复使用，每次都能让代码质量上一个台阶。

提取函数：把意图说清楚

提取函数是最基础的重构手法。说白了，就是把一段代码拿出来，给它起个好名字，变成一个独立的函数。

为什么要这么做？因为代码的可读性不在于它有多短，而在于它有多容易理解。你想想看，一个函数里塞了太多细节，读者就得逐行去猜「这段在干嘛」。提取函数就是把「怎么做」变成「做什么」。

举个例子，我之前接手过一个网络协议栈的代码，里面有一段这样的逻辑：

// 检查报文是否超时
if (current_time - packet->send_time > 5000 && 
    packet->retry_count > 3 && 
    packet->state == WAITING_ACK) {
    // 处理超时
    packet->state = TIMEOUT;
    resend_packet(packet);
    packet->retry_count++;
}

这段代码本身没问题，但每次读到这里都得停下来想：「哦，这是在判断超时」。我把它提取成一个函数：

if (is_packet_timed_out(packet)) {
    handle_timeout(packet);
}

你看，调用处变得一目了然。判断逻辑被封装在 is_packet_timed_out 里，想了解细节再去看函数实现。这就是提取函数的精髓——分层阅读。

内联函数：别过度封装

有提取就有内联。内联函数是提取函数的逆操作——当一个函数体比函数名更容易理解时，就该把它内联回去。

我曾经在一个项目中看到这样的代码：

int result = calculate_result(a, b, c);

// 然后翻到文件末尾才看到
int calculate_result(int a, int b, int c) {
    return a + b - c;
}

这种函数除了增加阅读负担，没有任何价值。函数名 calculate_result 比 a + b - c 更抽象、更难懂。这时候就应该内联：

int result = a + b - c;

什么时候该内联？我总结了三个场景：

• 函数体比函数名更直观（比如上面那个例子）
• 函数只被调用一次，且调用处上下文清晰
• 函数内部逻辑过于简单，封装反而增加了间接性

引入参数对象：把散弹变成炮弹

这个手法解决的是「参数过多」的问题。我见过最夸张的一个函数有12个参数，调用的时候得对着文档一个一个填。这种代码别说维护了，看着都累。

引入参数对象，就是把一组经常一起出现的参数，封装成一个结构体。举个例子：

// 重构前
void draw_rect(int x, int y, int width, int height, 
               int border_width, int border_color, 
               int fill_color, int opacity) {
    // ...
}

// 调用
draw_rect(10, 20, 100, 50, 2, 0xFF0000, 0x00FF00, 128);

这代码谁看得懂？第5个参数是边框宽度还是颜色？我每次都得数一遍。引入参数对象后：

typedef struct {
    int x, y;
    int width, height;
} Rect;

typedef struct {
    int width;
    int color;
} Border;

typedef struct {
    int color;
    int opacity;
} Fill;

void draw_rect(Rect rect, Border border, Fill fill) {
    // ...
}

// 调用
Rect r = {10, 20, 100, 50};
Border b = {2, 0xFF0000};
Fill f = {0x00FF00, 128};
draw_rect(r, b, f);

现在参数分组清晰，每个结构体都有自己的语义。调用的时候，一眼就能看出每个参数的含义。

分解条件表达式：消灭嵌套地狱

条件表达式是代码中最容易变脏的地方。一个 if-else 嵌套七八层，逻辑复杂到没人敢动。分解条件表达式，就是把复杂的条件判断拆成多个小函数。

我记得有个支付系统的代码，判断一笔交易是否可退款，条件写了整整50行：

if (transaction->status == COMPLETED) {
    if (transaction->type == CREDIT_CARD) {
        if (current_time - transaction->time < 30 * 24 * 3600) {
            if (transaction->amount < 10000) {
                // 可以退款
                ...
            }
        }
    }
}

这种嵌套结构，改一个条件就得把所有层级都理解一遍。我把它分解成：

if (is_refundable(transaction)) {
    // 可以退款
    ...
}

bool is_refundable(Transaction *t) {
    return is_completed(t) 
        && is_credit_card(t) 
        && is_within_refund_period(t) 
        && is_below_refund_limit(t);
}

bool is_completed(Transaction *t) { return t->status == COMPLETED; }
bool is_credit_card(Transaction *t) { return t->type == CREDIT_CARD; }
bool is_within_refund_period(Transaction *t) {
    return current_time - t->time < 30 * 24 * 3600;
}
bool is_below_refund_limit(Transaction *t) {
    return t->amount < 10000;
}

现在主逻辑只有一行 if，每个条件都是独立的函数，可以单独测试、单独修改。这就是分解条件表达式的威力。

四种手法的关系

这四种手法不是孤立的。在实际重构中，它们经常配合使用。比如：

• 先提取函数，把大函数拆小
• 发现参数过多，引入参数对象
• 遇到复杂条件，分解条件表达式
• 发现某些函数太简单，内联回去

说白了，重构是一个持续调整的过程。没有一步到位的完美设计，只有不断打磨的代码质量。

实际案例：一个完整的重构过程

最后，我分享一个真实案例。这是我曾经维护过的一个嵌入式系统，里面有个函数负责处理传感器数据：

void process_sensor_data(int sensor_id, int raw_value, int threshold,
                         int min_range, int max_range, int calibration_offset,
                         int filter_window, int filter_threshold) {
    // 检查传感器是否有效
    if (sensor_id > 0 && sensor_id < 32) {
        // 检查数值范围
        if (raw_value >= min_range && raw_value <= max_range) {
            // 应用校准
            int calibrated = raw_value + calibration_offset;
            // 应用滤波
            int filtered = apply_filter(calibrated, filter_window, filter_threshold);
            // 检查是否超过阈值
            if (filtered > threshold) {
                trigger_alarm(sensor_id, filtered);
            }
        }
    }
}

这个函数有8个参数，三层嵌套，还混着注释。我用了20分钟做了以下重构：

1. 引入参数对象：把传感器配置参数封装成 SensorConfig 结构体
2. 分解条件表达式：把三个条件判断拆成 is_valid_sensor、is_in_range、is_above_threshold
3. 提取函数：把校准和滤波逻辑提取成 calibrate_and_filter

重构后的代码：

typedef struct {
    int id;
    int threshold;
    int min_range;
    int max_range;
    int calibration_offset;
    int filter_window;
    int filter_threshold;
} SensorConfig;

void process_sensor_data(SensorConfig *cfg, int raw_value) {
    if (!is_valid_sensor(cfg)) return;
    if (!is_in_range(cfg, raw_value)) return;
    
    int processed = calibrate_and_filter(cfg, raw_value);
    if (is_above_threshold(cfg, processed)) {
        trigger_alarm(cfg->id, processed);
    }
}

参数从8个变成2个，嵌套从3层变成0层，每个函数只做一件事。这就是函数级别重构的魅力——改的是结构，提升的是可维护性。