动态参数下函数调用的策略模式实践-js教程-PHP中文网

动态参数下函数调用的策略模式实践

本文探讨了在JavaScript/TypeScript中，如何优雅地处理根据不同业务场景（如面试类型）调用具有不同参数签名的函数。通过引入策略模式，我们将具体业务逻辑封装到独立的策略类中，从而实现核心调用逻辑的统一与灵活性，有效解决了在动态选择函数时参数不匹配的问题，提升了代码的可维护性和可扩展性。

挑战：动态函数调用与可变参数

在开发过程中，我们经常会遇到需要根据特定条件动态调用不同函数的场景。一个常见的例子是，根据面试类型（如技术面试或hr面试）来验证招聘人员。然而，这些验证函数可能需要不同的参数。

考虑以下初始设计：

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),
    },
  },
};

登录后复制

当尝试统一调用 validateRecruiters 时，问题便浮现了：

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

登录后复制

TECHNICAL_INTERVIEW 类型的 validateRecruiters 需要两个参数，而 HR_INTERVIEW 类型则需要四个参数。直接在调用点统一传递参数会变得非常困难，因为不同分支需要的参数数量和类型不一致，导致代码难以维护和扩展。

解决方案：策略模式 (Strategy Pattern)

为了解决上述问题，我们可以采用策略模式。策略模式允许在运行时选择算法的行为。它通过定义一系列算法，将每一个算法封装起来，并使它们可以相互替换。这意味着，我们可以为每种面试类型定义一个“策略”，每个策略都封装了其特有的 validateRecruiters 逻辑，同时提供一个统一的接口。

1. 定义策略接口

首先，我们需要定义一个公共的接口或抽象类，所有具体策略都将实现或继承它。这个接口将包含 validateRecruiters 方法，并使用 ...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 {
    // HR面试需要额外的参数，通过解构或直接传递...params来获取
    const [param3, param4] = params;
    return matchHrRecruiters(recruiters, recruit as THrRecruit, param3, param4);
  }
}

登录后复制

注意：在 HrInterviewStrategy 中，我们通过 ...params 接收所有额外参数，并根据需要解构或使用它们。而 TechnicalInterviewStrategy 虽然也接收 ...params，但它只使用了前两个必需参数，忽略了其余的。这是策略模式处理可变参数的关键。

3. 重构处理器对象

现在，我们可以更新 recruitersCategoryHandlers 对象，使其不再直接包含匿名函数，而是引用具体的策略实例。

怪兽AI数字人

数字人短视频创作，数字人直播，实时驱动数字人

查看详情

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

登录后复制

4. 统一调用策略方法

通过策略模式，现在可以统一地调用 validateRecruiters 方法，无论具体是哪种面试类型。所有可能的参数都可以在调用点传递，由具体的策略类决定如何使用它们。

// 假设已确定面试类别及其他所需参数
const interviewCategory = 'HR_INTERVIEW'; // 示例：可以是动态获取的值
const param3 = 'someValue3'; // 示例：根据业务逻辑传入
const param4 = 'someValue4'; // 示例：根据业务逻辑传入
const slotsWithEmail = {}; // 替换为实际值
const initialRecruiters = recruitersCategoryHandlers[interviewCategory].getter(); // 获取初始招聘者

// 统一调用 validateRecruiters
const matchedSlots = getMatchingSlots(
  recruitersCategoryHandlers[interviewCategory].setter.validateRecruiters(
    initialRecruiters,
    slotsWithEmail, // 对应 recruit 参数
    param3,         // 对应 param3
    param4          // 对应 param4
  ),
  slotsWithEmail
);

登录后复制

完整示例代码

import { getHrRecruiters, getRecruiters } from '../queue';
import { validateTechnicalInterview } from './validateTechnicalInterview';
import { matchHrRecruiters } from './matchHrRecruiters';
import { THrInterviewer, THrRecruit, TRecruit } 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, ..._params: any[]): any {
    // 技术面试只关心前两个参数，忽略 _params
    console.log("Executing TechnicalInterviewStrategy...");
    return validateTechnicalInterview(recruiters, recruit);
  }
}

// 2. 实现HR面试策略
class HrInterviewStrategy implements ValidateRecruitersStrategy {
  validateRecruiters(recruiters: THrInterviewer[], recruit: TRecruit | THrRecruit, ...params: any[]): any {
    // HR面试需要额外的参数
    console.log("Executing HrInterviewStrategy...");
    const [param3, param4] = params;
    return matchHrRecruiters(recruiters, recruit as THrRecruit, param3, param4);
  }
}

// 3. 定义招聘者类别处理器，使用策略模式
export const recruitersCategoryHandlers = {
  TECHNICAL_INTERVIEW: {
    getter: getRecruiters,
    setter: new TechnicalInterviewStrategy(),
  },
  HR_INTERVIEW: {
    getter: getHrRecruiters,
    setter: new HrInterviewStrategy(),
  },
};

// 假设的外部函数和类型
function getMatchingSlots(validatedRecruiters: any, slots: any): any {
  console.log("Getting matching slots with:", validatedRecruiters);
  // 实际逻辑
  return validatedRecruiters;
}

// 假设的类型 EInterviewCategory
type EInterviewCategory = 'TECHNICAL_INTERVIEW' | 'HR_INTERVIEW';

// 模拟外部依赖函数
function getRecruiters(): THrInterviewer[] { return [{ id: 'tech1' }]; }
function getHrRecruiters(): THrInterviewer[] { return [{ id: 'hr1' }]; }
function validateTechnicalInterview(recruiters: THrInterviewer[], recruit: TRecruit | THrRecruit): any {
  console.log("validateTechnicalInterview called with:", recruiters, recruit);
  return { validTechRecruiters: recruiters };
}
function matchHrRecruiters(recruiters: THrInterviewer[], recruit: THrRecruit, p3: any, p4: any): any {
  console.log("matchHrRecruiters called with:", recruiters, recruit, p3, p4);
  return { matchedHrRecruiters: recruiters, p3, p4 };
}

// --- 实际调用示例 ---

// 确定面试类别和所需参数
const interviewCategory: EInterviewCategory = 'HR_INTERVIEW'; // 也可以是 'TECHNICAL_INTERVIEW'
const recruitData: TRecruit | THrRecruit = { id: 'someRecruitId', name: 'John Doe' }; // 模拟 recruit 数据
const param3 = 'projectA';
const param4 = 'teamB';
const slotsWithEmail = { slot1: 'email1' }; // 模拟 slotsWithEmail

// 获取初始招聘者
const initialRecruiters = recruitersCategoryHandlers[interviewCategory].getter();

// 调用 validateRecruiters
const validatedResult = recruitersCategoryHandlers[interviewCategory].setter.validateRecruiters(
  initialRecruiters,
  recruitData,
  param3,
  param4
);

// 获取匹配的槽位
const matchedSlots = getMatchingSlots(validatedResult, slotsWithEmail);

console.log("Final matched slots:", matchedSlots);

// 另一个例子：TECHNICAL_INTERVIEW
const techInterviewCategory: EInterviewCategory = 'TECHNICAL_INTERVIEW';
const techRecruitData: TRecruit = { id: 'techRecruit', name: 'Jane Smith' };
const techInitialRecruiters = recruitersCategoryHandlers[techInterviewCategory].getter();

const techValidatedResult = recruitersCategoryHandlers[techInterviewCategory].setter.validateRecruiters(
  techInitialRecruiters,
  techRecruitData,
  // 对于技术面试，这里即使传入 param3, param4 也会被 TechnicalInterviewStrategy 忽略
  'extraParam1', 'extraParam2'
);
const techMatchedSlots = getMatchingSlots(techValidatedResult, slotsWithEmail);
console.log("Final matched slots for tech interview:", techMatchedSlots);

登录后复制

注意事项与优点

灵活性和可扩展性：
- 新增面试类型： 如果需要添加新的面试类型（例如 PRODUCT_INTERVIEW），只需创建一个新的策略类实现 ValidateRecruitersStrategy 接口，并将其添加到 recruitersCategoryHandlers 对象中即可，无需修改现有代码。这完全符合“开闭原则”。
- 参数变化： 即使未来某个面试类型的参数需求发生变化，也只需修改对应的策略类，而不会影响其他策略或核心调用逻辑。
代码清晰度与可维护性：
- 每个策略类都专注于一个特定的算法或行为，使得代码结构更加清晰，职责分离。
- 避免了在主逻辑中出现大量的 if/else if 或 switch 语句来判断面试类型并调用不同签名的函数，降低了复杂性。
统一的调用接口：
- 通过 ValidateRecruitersStrategy 接口和 ...params: any[]，我们为所有 validateRecruiters 方法提供了一个统一的调用签名。
- 在调用时，可以一次性传递所有可能的参数，具体的策略类会根据自身需求选择性地使用这些参数。
类型安全（TypeScript）：
- 虽然 ...params: any[] 提供了最大的灵活性，但在 TypeScript 中，可以进一步结合类型守卫或更复杂的泛型来增强类型安全性，如果不同策略的参数类型差异非常大且需要严格控制。然而，对于本例中部分参数是可选或不相关的情况，any[] 是一个实用且有效的方案。