在运行时确定回调函数的签名

Question

    interface IOne { (j: string): number; }
    interface ITwo { (j: number): number; }
    function dualArg(i: string, process: IOne | ITwo): number {
        // something like this
        if (process instanceof ITwo) {
            // call with numeric arg
            return process(i);
        } else {
            // conver to number
            return process(+i);
        }
    }
    function inc(i: number): number {
        return ++i;
    }
    function idem(text: string): number {
        return +text;
    }
    it('determine function signature', () => {
        expect(dualArg('1', inc)).toBe(2);
        expect(dualArg('1', idem)).toBe(1);
    })

如果我使用某种硬编码条件，例如process.prototype.constructor.name==='idem'，我会得到Typescript错误消息:不能调用其类型缺乏调用签名的表达式。类型“iOne itwo”没有兼容的调用签名。

当然，我可以在这里定义process:any来禁用任何TypeScript检查，代码将编译并运行，但我的目标是能够仅通过签名来区分函数（而不依赖于其他约定，如名称或其他标志）。

Answer 1

问题是，在运行时，所有类型信息都丢失了。因此，您不能在运行时直接推断函数的类型（超出了它是函数的事实）。

您可以做的是创建一个函数类型，该函数类型也具有确定类型的属性。并使用函数来构建函数：

enum Type { One, Two}
interface IOne { (j: string): number; type: Type.One }
interface ITwo { (j: number): number; type: Type.Two}
function dualArg(i: string, process: IOne | ITwo): number {
    if (process.type === Type.One) {
        // Type guard above, process is of type IOne
        return process(i);
    } else {
        // Type guard above, process is of type ITwo
        return process(+i);
    }
}
function inc(i: number): number {
    return ++i;
}
function idem(text: string): number {
    return +text;
}

function oneFunction(fn: (j: string)=> number) : IOne{
    return Object.assign(fn, { type: Type.One as Type.One });
}

function twoFunction(fn: (j: number)=> number) : ITwo{
    return Object.assign(fn, { type: Type.Two as Type.Two });
}

dualArg("", twoFunction(inc));
dualArg("", oneFunction(idem));

对于您的简单示例来说，这可能有些过头了（您可以定义dualarg)的两个版本，但是如果函数的创建和用法相距甚远，并且在这两个版本之间重用了更多代码，那么这种方法可能是有意义的。