动态参数签名的函数调用：使用策略模式实现灵活的业务逻辑-js教程-PHP中文网

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

本文探讨了在JavaScript/TypeScript中，如何优雅地处理根据不同业务场景（如面试类型）调用参数签名不同的函数。通过引入策略设计模式，我们将展示如何定义统一的接口，封装各自的业务逻辑，从而实现代码的解耦、提高可维护性和扩展性，有效解决动态参数传递的挑战。

业务场景与问题描述

在复杂的业务系统中，我们经常会遇到需要根据特定条件执行不同操作的情况。例如，在一个招聘系统中，根据面试类型（技术面试或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 方法会根据其内部封装的逻辑，调用实际的验证函数并传递所需的参数。

腾讯智影-AI数字人

基于AI数字人能力，实现7*24小时AI数字人直播带货，低成本实现直播业务快速增增，全天智能在线直播

查看详情

// 技术面试策略
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);

登录后复制

优点与注意事项

优点：

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

注意事项：

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