如何根据参数值在TypeScript函数内收窄类型签名？

你遇到的核心问题是：当解构CalculateParameters联合类型时，TypeScript无法跟踪operation和args之间的类型关联——它仅知道operation是keyof Calculator，args是所有操作参数的联合集合，而非当前operation对应的具体参数列表，因此无法在switch分支中自动收窄args的类型。

同时，你需要让calculate函数的返回值类型自动匹配Calculator中对应方法的返回类型，支持非number类型的返回值。

函数重载可以明确每个操作对应的参数和返回值类型，既保证外部调用的类型安全，也能让编译器在函数内部正确收窄类型，且代码简洁易维护：

interface Calculator {
    plus: (a: number, b: number) => number;
    unaryPlus: (a: number) => number;
    // 示例：添加返回string类型的方法
    stringify: (a: number) => string;
}

// 为每个操作定义重载签名（外部调用时可见）
function calculate(operation: "plus", a: number, b: number): number;
function calculate(operation: "unaryPlus", a: number): number;
function calculate(operation: "stringify", a: number): string;

// 实现签名（仅内部使用，参数类型宽松但受重载约束）
function calculate(operation: keyof Calculator, ...args: any[]) {
    switch (operation) {
        case "plus":
            // 此处args被正确推断为[number, number]，无undefined警告
            return args[0] + args[1];
        case "unaryPlus":
            return args[0];
        case "stringify":
            return args[0].toString();
        default:
            throw new Error("Unknown operation.");
    }
}

// 外部调用类型检查正常，返回值类型自动推断
const x = calculate("plus", 1, 2); // number
const y = calculate("unaryPlus", 1); // number
const z = calculate("stringify", 42); // string

如果偏好保留原有的元组参数结构，可以通过自定义类型守卫重新建立operation与args的类型关联，避免类型断言和重复代码：

interface Calculator {
    plus: (a: number, b: number) => number;
    unaryPlus: (a: number) => number;
    stringify: (a: number) => string;
}

type CalculateParameters = {
    [P in keyof Calculator]: [P, ...Parameters<Calculator[P]>];
}[keyof Calculator];

// 自定义类型守卫：判断当前operation对应的args是否符合参数类型
function matchesOperationParams<T extends keyof Calculator>(
    operation: keyof Calculator,
    args: unknown[],
    targetOp: T
): args is Parameters<Calculator[T]> {
    return operation === targetOp;
}

const calculate = (...params: CalculateParameters) => {
    const [operation, ...args] = params;
    switch (operation) {
        case "plus":
            if (matchesOperationParams(operation, args, "plus")) {
                // args被收窄为[number, number]
                return args[0] + args[1];
            }
            throw new Error("Invalid parameters for 'plus'");
        case "unaryPlus":
            if (matchesOperationParams(operation, args, "unaryPlus")) {
                return args[0];
            }
            throw new Error("Invalid parameters for 'unaryPlus'");
        case "stringify":
            if (matchesOperationParams(operation, args, "stringify")) {
                return args[0].toString();
            }
            throw new Error("Invalid parameters for 'stringify'");
        default:
            throw new Error("Unknown operation.");
    }
};

// 调用正常，返回值类型正确推断
const x = calculate("plus", 1, 2); // number
const y = calculate("unaryPlus", 1); // number
const z = calculate("stringify", 42); // string

• 函数重载方案的优势在于代码直观，无需额外类型工具，且能精确控制每个操作的参数和返回类型；
• 类型守卫方案保留了原有的元组参数结构，通过通用的类型守卫函数避免了重复代码，适合需要保持参数格式一致性的场景；
• 两种方案都能让TypeScript自动推断返回值类型，完美支持Calculator中不同返回类型的方法。

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