TypeScript 泛型与联合函数类型下Record存储多函数的调用报错问题

你遇到的Expected 0 arguments, but got 1报错，是TS两条校验规则叠加导致的：

• 多函数组成的联合类型，调用时的参数校验规则为：传入的参数必须是联合内所有函数都能接受的参数集合，才允许调用
• 你之前将records直接声明为Record<string, MyFunctionUnion<B, C>>，相当于告知编译器：无论通过哪个字符串键取值，拿到的都是MyAFunctionType | MyBFunctionType<B> | MyCFunctionType<C>的联合，完全丢失了「a键对应无参函数、b/c键对应带参函数」的绑定关系。
• 由于联合内包含一个完全不接受入参的MyAFunctionType，整个联合类型的合法可调用参数集仅剩空集——不管实际拿到的是哪个函数，编译器都不允许传入任何参数，自然抛出参数数量不匹配的错误。

在Record结构中存储多个不同签名的函数是完全可行的，没有任何TS类型系统层面的实现障碍。之前的问题本质是类型定义思路偏差：没有用类型表达出键和值的对应绑定关系，只是把所有值混成了无差别的大联合，才触发了联合函数的调用限制。

核心是通过交叉类型同时满足两个目标：

• 对已知的固定键（a/b/c），保留键和对应函数签名的强绑定，不受联合类型规则的干扰
• 保留字符串索引的扩展能力，支持后续新增自定义键存储其他合规函数

修正后的完整可编译代码：

interface MyAFunctionType {
  (): { type: string };
}

interface MyBFunctionType<B> {
  (b?: B): { type: string, key?: B | undefined };
}

interface MyCFunctionType<C> {
  (c?: C): { type: string, param?: C | undefined };
}

function MyAFunction(): MyAFunctionType {
    return function() {
        return {
            type: 'hello'
        }
    }
}

function MyBFunction<B>(): MyBFunctionType<B> {
    return function(key?: B | undefined) {
        if (typeof key === 'undefined') {
            return {
                key,
                type: 'hello'
            }
        }
        return {
            key,
            type: 'hello'
        }
    }
}

function MyCFunction<C>(): MyCFunctionType<C> {
    return function(key?: C | undefined) {
        if (typeof key === 'undefined') {
            return {
                key,
                type: 'hello'
            }
        }
        return {
            key,
            type: 'hello'
        }
    }
}

type MyFunctionUnion<B, C> = MyAFunctionType | MyBFunctionType<B> | MyCFunctionType<C>;
// 定义固定键和函数签名的强绑定映射
type FunctionMap<B, C> = {
    a: MyAFunctionType;
    b: MyBFunctionType<B>;
    c: MyCFunctionType<C>;
}

function MyRecordFunction<B, C>() {
    // 交叉类型组合「固定键强类型」+「可扩展字符串索引」
    const records: FunctionMap<B, C> & Record<string, MyFunctionUnion<B, C>> = {
        a: MyAFunction(),
        b: MyBFunction<B>(),
        c: MyCFunction<C>(),
    };

    return records;
}

interface MyBInterface {
    foo: 'bar'
}

interface MyCInterface {
    baz: 'bus'
}

const myRecords = MyRecordFunction<MyBInterface, MyCInterface>();

// 以下调用全部通过编译校验
myRecords.a();
myRecords.b({ foo: 'bar' });
myRecords.c({ baz: 'bus' }); // 修正原代码中的拼写错误

修正后可以获得的能力：

• 访问myRecords.a时，编译器明确识别它为无参函数，传入参数反而会触发错误提示
• 访问myRecords.b/myRecords.c时，编译器明确识别它接受对应泛型类型的可选参数，传参不会再触发之前的2554号错误
• 后续新增任意自定义键存储函数时，只要传入的函数符合MyFunctionUnion的类型要求，依然可以通过字符串索引正常存取

• 不要为了快速消除报错，直接给函数调用加as any类型断言，这样会完全丢失TS的类型校验能力，违背使用TS的初衷
• 联合类型的函数调用限制是TS的原生设计，目的是避免调用联合内某类不匹配参数的函数。只要在类型层面把键和值的对应关系绑定完成，就不会再触发这类限制。

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