挑战：动态函数调用与可变参数
在开发过程中，我们经常会遇到需要根据特定条件动态调用不同函数的场景。一个常见的例子是，根据面试类型（如技术面试或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 对象，使其不再直接包含匿名函数，而是引用具体的策略实例。
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[] 是一个实用且有效的方案。
总结
通过引入策略模式，我们成功解决了在动态选择函数时，函数参数签名不一致的挑战。这种设计模式不仅使代码更加灵活、易于扩展，而且显著提升了代码的可读性和可维护性。在面对需要根据运行时条件执行不同行为的场景时，策略模式提供了一种优雅且强大的解决方案。
