动态函数的返回类型

Question

我有一个 function，它唯一的逻辑是执行传入的 function。

const funcRunner = async (func: Function) => {
   return await func()
}

我知道无论传入的 function 的响应如何，都将是同一个 function 的响应。

然而，这个 function 返回签名被推断为Promise<any> 。 有什么办法可以保留原来function的响应类型？

const bool = async isExample(): Promise<boolean> => true;

// result should be boolean, not any
const result = await funcRunner(isExample);

Answer 1

您可以将其设为通用，这样 TypeScript 就可以从调用站点推断出来，并使用实用程序类型ReturnType来获取其返回类型：

const funcRunner = async <FuncType extends () => any>(
    func: FuncType
): Promise<ReturnType<FuncType>> => {
   return await func();
};

使用示例：

async function example1() {
    return 1;
}

async function example2() {
    return "a";
}

(async() => {
    const result1 = await funcRunner(example1);
    //    ^? const result1: number
    const result2 = await funcRunner(example2);
    //    ^? const result2: string
})();

游乐场链接

如果愿意，您可以通过不将funcRunner设为async来使其更通用一些，然后它可以运行async或非异步函数，而无需向非async函数添加async ：

const funcRunner = <FuncType extends () => any>(
    func: FuncType
): ReturnType<FuncType> => {
    return func();
};

游乐场链接

如果您想确保在异步堆栈跟踪中看到funcRunner ，您可能不想这样做，但如果您不为此烦恼，那很好。

---

只是为了好玩：如果你想让funcRunner调用需要参数的函数，你可以添加一个完全类型化的args参数：

async function funcRunner<FuncType extends (...args: any[]) => any>(
    func: FuncType,
    args: Parameters<FuncType>
): Promise<ReturnType<FuncType>> {
    return await func(...args);
}

如果你想让第二个参数对于不带任何参数的函数是可选的，我认为你需要重载它：

async function funcRunner<FuncType extends () => any>(
    func: FuncType,
): Promise<ReturnType<FuncType>>;
async function funcRunner<FuncType extends (...args: any[]) => any>(
    func: FuncType,
    args: Parameters<FuncType>
): Promise<ReturnType<FuncType>>;
async function funcRunner<FuncType extends (...args: any[]) => any>(
    func: FuncType,
    args?: Parameters<FuncType>
): Promise<ReturnType<FuncType>> {
    if (args) {
        return await func(...args);
    }
    return await func();
}

重载的用法示例：

async function example1() {
    return 1;
}

async function example2() {
    return "a";
}

function example3() {
    return Math.random() < 0.5;
}

function example4(num: number) {
    return num * 42;
}

(async() => {
    const result1 = await funcRunner(example1);
    //    ^?
    const result2 = await funcRunner(example2, []); // <=== Args is allowed even when optional...
    //    ^?
    const badResult1 = await funcRunner(example2, ["x"]); // <=== ...but it can't have anything in it
    //    ^?
    const result3 = await funcRunner(example3);
    //    ^?
    const result4 = await funcRunner(example4, [3]);
    //    ^?
    const badResult2 = await funcRunner(example4); // <=== Error as desired, need args!
    //    ^?
    const badResult3 = await funcRunner(example4, ["x"]); // <=== Error as desired, wrong type!
    //    ^?
})();

游乐场链接

当然，您也可以始终使那个async -neutral； 游乐场链接。

Answer 2

可以定义一个泛型来运行 function：

type Runnable<T> = () => Promise<T>;

然后将其应用于您的funcRunner

async function funcRunner<T>(runnable: Runnable<T>): Promise<T> {
  return await runnable();
}

您可以选择使用内联输入：

async function funcRunner<T>(runnable: () => Promise<T>): Promise<T> {
  return await runnable();
}

用法示例：

async function example1(): Promise<number> {
  return 1;
}


funcRunner(example1)
    .then((result: number) => console.log(result))