动态参数函数调用：策略模式灵活实现业务逻辑

本文深入探讨了在JavaScript/TypeScript项目中，如何利用**策略设计模式**优雅地解决动态参数函数调用的难题。面对不同业务场景（如技术面试与HR面试）下函数参数签名各异的挑战，传统方法往往导致代码冗余和难以维护。本文通过实例展示了如何定义统一的策略接口，并为每种业务场景创建具体的策略类，将验证逻辑封装在各自的策略中。这种方法实现了代码的**解耦**和**高内聚**，显著提升了代码的**可维护性**和**可扩展性**。文章还详细分析了策略模式的优点、注意事项，以及适用场景，为开发者提供了一种在复杂业务逻辑中实现灵活函数调用的有效方案。掌握策略模式，让你的代码更具弹性，轻松应对各种业务需求变化！

业务场景与问题描述

在复杂的业务系统中，我们经常会遇到需要根据特定条件执行不同操作的情况。例如，在一个招聘系统中，根据面试类型（技术面试或HR面试）来验证招聘人员的逻辑可能有所不同。最初的设计可能采用一个查找表（lookup table）来存储不同类型面试对应的处理器：

import { getHrRecruiters, getRecruiters } from '../queue';
import { validateTechnicalInterview } from './validateTechnicalInterview';
import { matchHrRecruiters } from './matchHrRecruiters';
import { THrInterviewer, THrRecruit, TRecruit } from '../../types';

export const recruitersCategoryHandlers = {
  TECHNICAL_INTERVIEW: {
    getter: getRecruiters,
    setter: {
      validateRecruiters: (
        recruiters: THrInterviewer[],
        recruit: TRecruit | THrRecruit
      ) => validateTechnicalInterview(recruiters, recruit),
    },
  },
  HR_INTERVIEW: {
    getter: getHrRecruiters,
    setter: {
      validateRecruiters: (
        recruiters: THrInterviewer[],
        recruit: TRecruit | THrRecruit,
        param3: any,
        param4: any
      ) => matchHrRecruiters(recruiters, recruit as THrRecruit, param3, param4),
    },
  },
};

在这种结构中，recruitersCategoryHandlers 对象作为调度器，根据 interviewCategory 动态获取 getter 和 setter。然而，问题在于 setter.validateRecruiters 方法在 TECHNICAL_INTERVIEW 和 HR_INTERVIEW 两种情况下接收的参数数量和类型不同。当尝试统一调用时，例如：

const matchedSlots = getMatchingSlots(
  recruitersCategoryHandlers[
    interviewCategory as EInterviewCategory
  ].setter.validateRecruiters(???), // 此处参数如何传递？
  slotsWithEmail
);

我们面临一个挑战：如何以一种通用的方式调用 validateRecruiters 函数，使其能够适应不同面试类型所需的参数差异？直接传递所有可能参数会导致代码冗余和类型不安全，而条件判断又会使调用逻辑变得复杂。

解决方案：策略设计模式

为了解决上述问题，我们可以引入策略设计模式（Strategy Design Pattern）。策略模式允许在运行时选择算法的行为。它通过定义一系列算法（策略），将每个算法封装起来，并使它们可以相互替换。

在该场景中，不同的 validateRecruiters 逻辑就是不同的策略。我们可以定义一个统一的策略接口，然后为每种面试类型实现具体的策略类。

1. 定义策略接口

首先，定义一个通用的策略接口 ValidateRecruitersStrategy。这个接口的 validateRecruiters 方法需要能够处理所有可能的参数组合。最灵活的方式是使用可变参数（rest parameters）...params: any[]。

interface ValidateRecruitersStrategy {
  validateRecruiters(
    recruiters: THrInterviewer[],
    recruit: TRecruit | THrRecruit,
    ...params: any[]
  ): any;
}

2. 实现具体策略类

接下来，为每种面试类型实现具体的策略类，它们都将实现 ValidateRecruitersStrategy 接口。在每个具体策略类中，validateRecruiters 方法会根据其内部封装的逻辑，调用实际的验证函数并传递所需的参数。

// 技术面试策略
class TechnicalInterviewStrategy implements ValidateRecruitersStrategy {
  validateRecruiters(
    recruiters: THrInterviewer[],
    recruit: TRecruit | THrRecruit
  ): any {
    // 仅使用前两个参数
    return validateTechnicalInterview(recruiters, recruit);
  }
}

// HR面试策略
class HrInterviewStrategy implements ValidateRecruitersStrategy {
  validateRecruiters(
    recruiters: THrInterviewer[],
    recruit: TRecruit | THrRecruit,
    ...params: any[]
  ): any {
    // 使用所有传入的参数，并进行类型断言
    const [param3, param4] = params;
    return matchHrRecruiters(recruiters, recruit as THrRecruit, param3, param4);
  }
}

3. 更新处理器配置

现在，我们可以更新 recruitersCategoryHandlers 对象，使其 setter 属性存储相应策略类的实例，而不是直接的函数引用。

export const recruitersCategoryHandlers = {
  TECHNICAL_INTERVIEW: {
    getter: getRecruiters,
    setter: new TechnicalInterviewStrategy(), // 存储策略实例
  },
  HR_INTERVIEW: {
    getter: getHrRecruiters,
    setter: new HrInterviewStrategy(), // 存储策略实例
  },
};

4. 统一调用方式

通过策略模式，现在可以以一种统一且类型安全的方式调用 validateRecruiters。无论具体是哪种面试类型，我们都调用策略实例的 validateRecruiters 方法，并传入所有可能需要的参数。具体策略会根据自身逻辑选择使用哪些参数。

// 假设已获取面试类别和相关参数
const interviewCategory: EInterviewCategory = 'HR_INTERVIEW'; // 或 'TECHNICAL_INTERVIEW'
const param3 = 'someValue3';
const param4 = 'someValue4';
const slotsWithEmail: any = {}; // 假设的插槽数据

// 获取招聘人员列表
const recruiters = recruitersCategoryHandlers[interviewCategory].getter();

// 调用策略模式的 validateRecruiters 方法
const matchedSlots = getMatchingSlots(
  recruitersCategoryHandlers[interviewCategory].setter.validateRecruiters(
    recruiters,
    slotsWithEmail, // 作为 recruit 参数传递
    param3,
    param4 // 额外参数，HR_INTERVIEW 策略会使用
  ),
  slotsWithEmail
);

console.log('匹配到的插槽:', matchedSlots);

完整代码示例：

import { getHrRecruiters, getRecruiters } from '../queue'; // 假设这些路径和函数存在
import { validateTechnicalInterview } from './validateTechnicalInterview'; // 假设这些路径和函数存在
import { matchHrRecruiters } from './matchHrRecruiters'; // 假设这些路径和函数存在
import { THrInterviewer, THrRecruit, TRecruit, EInterviewCategory } from '../../types'; // 假设这些类型存在

// 1. 定义策略接口
interface ValidateRecruitersStrategy {
  validateRecruiters(
    recruiters: THrInterviewer[],
    recruit: TRecruit | THrRecruit,
    ...params: any[]
  ): any;
}

// 2. 实现具体策略类
class TechnicalInterviewStrategy implements ValidateRecruitersStrategy {
  validateRecruiters(
    recruiters: THrInterviewer[],
    recruit: TRecruit | THrRecruit
  ): any {
    console.log('执行技术面试验证...');
    return validateTechnicalInterview(recruiters, recruit);
  }
}

class HrInterviewStrategy implements ValidateRecruitersStrategy {
  validateRecruiters(
    recruiters: THrInterviewer[],
    recruit: TRecruit | THrRecruit,
    ...params: any[]
  ): any {
    console.log('执行HR面试匹配...');
    const [param3, param4] = params;
    return matchHrRecruiters(recruiters, recruit as THrRecruit, param3, param4);
  }
}

// 3. 定义 recruitersCategoryHandlers 使用策略模式
export const recruitersCategoryHandlers = {
  TECHNICAL_INTERVIEW: {
    getter: getRecruiters,
    setter: new TechnicalInterviewStrategy(),
  },
  HR_INTERVIEW: {
    getter: getHrRecruiters,
    setter: new HrInterviewStrategy(),
  },
};

// 模拟外部调用
// 假设这些函数和类型已定义
function getMatchingSlots(validatedResult: any, slots: any): any {
  console.log('获取匹配插槽:', validatedResult, slots);
  return validatedResult ? ['slot1', 'slot2'] : []; // 示例返回
}
// 模拟 getRecruiters, getHrRecruiters, validateTechnicalInterview, matchHrRecruiters
function getRecruiters(): THrInterviewer[] { return [{ id: 'tech1' }]; }
function getHrRecruiters(): THrInterviewer[] { return [{ id: 'hr1' }]; }
function validateTechnicalInterview(recruiters: THrInterviewer[], recruit: TRecruit | THrRecruit): boolean {
    console.log('实际调用 validateTechnicalInterview', recruiters, recruit);
    return true;
}
function matchHrRecruiters(recruiters: THrInterviewer[], recruit: THrRecruit, p3: any, p4: any): boolean {
    console.log('实际调用 matchHrRecruiters', recruiters, recruit, p3, p4);
    return true;
}


// 4. 统一调用示例
const interviewCategory: EInterviewCategory = 'HR_INTERVIEW'; // 切换为 'TECHNICAL_INTERVIEW' 尝试不同路径
const param3 = 'departmentA';
const param4 = 'levelSenior';
const slotsWithEmail = { candidateEmail: 'test@example.com' };
const recruitData: TRecruit | THrRecruit = { id: 'candidate1', name: 'John Doe' }; // 示例 recruit 数据

// 获取招聘人员
const currentRecruiters = recruitersCategoryHandlers[interviewCategory].getter();

// 调用策略模式的 validateRecruiters 方法
const validationResult = recruitersCategoryHandlers[interviewCategory].setter.validateRecruiters(
  currentRecruiters,
  recruitData,
  param3,
  param4
);

const matchedSlots = getMatchingSlots(validationResult, slotsWithEmail);
console.log(`最终匹配结果 (${interviewCategory}):`, matchedSlots);

// 尝试 TECHNICAL_INTERVIEW
const techInterviewCategory: EInterviewCategory = 'TECHNICAL_INTERVIEW';
const techRecruiters = recruitersCategoryHandlers[techInterviewCategory].getter();
const techValidationResult = recruitersCategoryHandlers[techInterviewCategory].setter.validateRecruiters(
    techRecruiters,
    recruitData
    // 注意这里没有传入 param3, param4，因为 TechnicalInterviewStrategy 不会使用它们
);
const techMatchedSlots = getMatchingSlots(techValidationResult, slotsWithEmail);
console.log(`最终匹配结果 (${techInterviewCategory}):`, techMatchedSlots);

优点与注意事项

优点：

1. 解耦性强： 将不同面试类型的验证逻辑从主调用逻辑中分离出来，降低了模块间的耦合度。
2. 可扩展性好： 当需要增加新的面试类型时（例如 PRODUCT_INTERVIEW），只需创建新的策略类并将其添加到 recruitersCategoryHandlers 中，无需修改现有代码，符合“开闭原则”。
3. 可维护性高： 每个策略类只负责一种验证逻辑，代码结构清晰，易于理解和维护。
4. 灵活性： 可以在运行时根据条件动态切换不同的验证策略。

注意事项：

1. 策略接口的参数设计： 策略接口 validateRecruiters 的参数签名需要足够通用，能够容纳所有具体策略可能需要的参数。使用可变参数 ...params: any[] 是一个有效的解决方案，但需要在具体策略内部进行参数的解析和类型检查。
2. 过度设计： 对于只有少量分支且未来变化不大的简单场景，直接使用 if/else 或 switch 语句可能更简单直接。策略模式适用于业务逻辑复杂、分支较多且需要频繁扩展的场景。
3. 参数传递的明确性： 尽管策略模式允许统一调用，但在实际调用时，仍需确保传入的参数能够满足当前所选策略的需求。如果某个策略严格依赖某个参数，而调用方没有提供，则可能导致运行时错误。在 TypeScript 中，可以通过更精细的类型定义来增强参数的安全性，例如为每个策略定义独立的 execute 方法，并在 recruitersCategoryHandlers 中存储不同接口的实例，但这会增加 recruitersCategoryHandlers 的类型复杂性。本例中的 ...params: any[] 是一种平衡了通用性和简洁性的方案。

总结

通过采用策略设计模式，我们成功地解决了在JavaScript/TypeScript中调用参数签名不同的函数这一常见挑战。它不仅使得代码结构更加清晰、易于扩展和维护，还提高了系统的灵活性和健壮性。在处理复杂且多变的业务逻辑时，策略模式是一个非常实用的设计工具。

今天关于《动态参数函数调用：策略模式灵活实现业务逻辑》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！