TypeScript中如何将联合类型元素映射到对应处理函数？

你遇到的核心问题是：当用Request联合类型的变量索引处理函数字典时，TypeScript无法自动关联变量的具体类型与对应处理函数的参数类型，导致参数被推断为冲突的交集类型（最终变成never）。

问题根源 #

你的requestHandlers类型定义本身是正确的，但在调用时：

• payload是Request联合类型，payload.type是'typeA' | 'typeB'
• 此时requestHandlers[payload.type]的类型是((r: RequestA) => void) | ((r: RequestB) => void)
• TypeScript对联合类型函数的调用要求参数必须满足所有函数的参数类型，也就是RequestA & RequestB——但这两个类型的type字段冲突，因此被简化为never，触发报错。

解决方案 #

方案1：用泛型函数封装调用逻辑（推荐）

通过泛型约束让TypeScript跟踪payload的具体类型与type字段的关联，确保处理函数参数类型匹配：

type Request = | RequestA | RequestB;

type RequestA = {
    type: 'typeA',
    propA: string,
    prop1: number
};

type RequestB = {
    type: 'typeB',
    propB: { val: string },
    prop2: string
};

// 明确定义处理函数映射类型
type RequestHandlerMap = {
  [T in Request as T['type']]: (r: T) => void;
};

const requestHandlers: RequestHandlerMap = {
    'typeA': (a) => {
      // 这里a会被自动推断为RequestA类型，可安全访问propA、prop1
      console.log(a.propA, a.prop1);
    },
    'typeB': (b) => {
      console.log(b.propB.val, b.prop2);
    },
};

// 泛型处理函数，关联payload类型与type字段
function handleRequest<T extends Request>(payload: T) {
  const handler = requestHandlers[payload.type];
  handler?.(payload); // 可选链调用，避免undefined
}

// 使用示例
const payloadA: RequestA = { type: 'typeA', propA: "hello", prop1: 3 };
handleRequest(payloadA);

const payloadB: RequestB = { type: 'typeB', propB: { val: "world" }, prop2: "test" };
handleRequest(payloadB);

方案2：类型断言（适合简单场景）

如果不想新增函数，可以在调用时用Extract工具类型断言payload的具体类型，确保类型安全：

const payload: RequestA = { type: 'typeA', propA: "hello", prop1: 3 };

const handler = requestHandlers[payload.type];
if (handler) {
  handler(payload as Extract<Request, { type: typeof payload.type }>);
}

方案3：类型守卫（适合少量请求类型）

通过显式的类型判断收窄payload类型，让TypeScript自动匹配处理函数参数：

const payload: Request = { type: 'typeA', propA: "hello", prop1: 3 };

if (payload.type === 'typeA') {
  requestHandlers[payload.type]!(payload); // payload被推断为RequestA
} else if (payload.type === 'typeB') {
  requestHandlers[payload.type]!(payload); // payload被推断为RequestB
}

总结 #

• 泛型函数方案最适合扩展，新增请求类型时无需修改调用逻辑，保持类型严格关联
• 类型断言和类型守卫适合简单场景，但扩展性较差

内容的提问来源于stack exchange，提问作者Nathaniel Hayman