Question

我正在尝试定义一个可以使用多个参数或单个对象调用的函数。单个对象只是支持的参数的容器。

这是我尝试的一个例子：

export type ExecutionArgs = {
    input: Observable<string>,
    whatever: SomeOtherType,
    foo?: string,
    bar?: number,
};

function execute(
    args: ExecutionArgs,
    ...rest: any[]
): Observable<string>;

function execute(
    input: Observable<string>,
    whatever: SomeOtherType,
    foo?: string,
    bar?: number,
): Observable<string>;

function execute(
    inputOrArgs,
    whatever,
    foo,
    bar,
) {
    // Extract arguments from object args if provided.
    if (arguments.length === 1) {
        return doThings(
            inputOrArgs.input,
            inputOrArgs.whatever,
            inputOrArgs.foo,
            inputOrArgs.bar,
        );
    }

    return doThings(
        inputOrArgs,
        whatever,
        foo,
        bar,
    );
}

调用我的函数时，可以正确检测类型。在下面的行中，我得到了input和bar上的预期错误。

execute('a', 'b', 'c', 'd');
execute({ input: 'a', whatever: 'b', foo: 'c' bar: 'd' });

但是在我的函数本身中，当我将变量或对象道具悬停时，打字稿只能在任何地方检测到any类型。

如何正确编写函数？

Answer 1

您遇到的是TypeScript的两个问题的组合：

在函数内部实现重载函数时，您始终会处理最通用的类型，any是因为未指定它们。
当前未键入arguments对象，即所有参数均为any;

通过使用元组的联合来指定您的重载，您可以解决两个问题：

type ExecuteArgs =
    | [Observable<string>, SomeOtherType, string?, number?]
    | [{
        input: Observable<string>,
        whatever: SomeOtherType,
        foo?: string,
        bar?: number,
    }]

function execute(
    ...args: ExecuteArgs
) {
    // Extract arguments from object args if provided.
    if (args.length === 1) {
        const [{ input, whatever, foo, bar }] = args;
        return doThings(
            input,
            whatever,
            foo,
            bar,
        );
    }
    const [input, whatever, foo, bar] = args;

    return doThings(
        input,
        whatever,
        foo,
        bar,
    );
}

具有多个参数或对象映射的Typescript函数

1 个答案: