泛型函数的Typescript ReturnType

Question

TypeScript 2.8 中的新 ReturnType 是一项非常有用的功能，可让您提取特定函数的返回类型。

function foo(e: number): number {
    return e;
}

type fooReturn = ReturnType<typeof foo>; // number

但是，我在泛型函数的上下文中使用它时遇到了问题。

function foo<T>(e: T): T {
    return e;
}

type fooReturn = ReturnType<typeof foo>; // type fooReturn = {}

type fooReturn = ReturnType<typeof foo<number>>; // syntax error

type fooReturn = ReturnType<(typeof foo)<number>>; // syntax error

有没有办法提取泛型函数会给出特定类型参数的返回类型？

Answer 1

TypeScript 编译器不会将 typeof foo 视为泛型类型。我会说这是编译器中的一个错误。

然而，TypeScript 有callable interfaces，它可以是通用的，没有任何问题，所以如果你引入一个与你的函数签名兼容的可调用接口，你可以像这样实现你自己的ReturnType 等价物：

function foo<T>(x: T): T {
  return x;
}


interface Callable<R> {
  (...args: any[]): R;
}

type GenericReturnType<R, X> = X extends Callable<R> ? R : never;

type N = GenericReturnType<number, typeof foo>; // number

Answer 2

如果你想得到一些特殊的泛型，你可以使用一个假函数来包装它。

const wrapperFoo = () => foo<number>()
type Return = ReturnType<typeof wrapperFoo>

更复杂的演示

function getList<T>(): {
  list: T[],
  add: (v: T) => void,
  remove: (v: T) => void,
  // ...blahblah
}
const wrapperGetList = () => getList<number>()
type List = ReturnType<typeof wrapperGetList>
// List = {list: number[], add: (v: number) => void, remove: (v: number) => void, ...blahblah}

Answer 3

如果您可以更改函数定义，我发现了一种很好且简单的方法来实现这一点。 在我的情况下，我需要使用带有通用函数的打字稿类型Parameters，正是我正在尝试Parameters<typeof foo<T>>，但实际上它不起作用。因此，实现这一点的最佳方法是通过接口函数定义更改函数定义，这也可以使用打字稿类型ReturnType。

以下是 OP 描述的案例：

function foo<T>(e: T): T {
   return e;
}

type fooReturn = ReturnType<typeof foo<number>>; // Damn! it throws error

// BUT if you try defining your function as an interface like this:

interface foo<T>{
   (e: T): T
}

type fooReturn = ReturnType<foo<number>> //it's number, It works!!!
type fooParams = Parameters<foo<string>> //it also works!! it is [string]

//and you can use the interface in this way
const myfoo: foo<number> = (asd: number) => {
    return asd;
};

myfoo(7);

Answer 4

这是我目前提取未导出内部类型的导入库（如 knex）的有效解决方案：

// foo is an imported function that I have no control over
function foo<T>(e: T): InternalType<T> {
    return e;
}

class Wrapper<T> {
  // wrapped has no explicit return type so we can infer it
  wrapped(e: T) {
    return foo<T>(e)
  }
}

type FooInternalType<T> = ReturnType<Wrapper<T>['wrapped']>
type Y = FooInternalType<number>
// Y === InternalType<number>

Answer 5

const wrapperFoo = (process.env.NODE_ENV === 'development' ? foo<number>() : undefined)!
type Return = typeof wrapperFoo

我什至会使用test 或typescript_helper 之类的随机字符串而不是development 代替development（只要TypeScript 不抛出错误），这样它就永远不会执行，因为它不会在运行时使用。

Answer 6

我找到了解决方案。你决定它是否符合你的需要:)

使用接口声明你的函数参数和返回类型

interface Foo<T, V> {
  (t: T, v: V): [T, V]
}

使用Parameters 和ReturnType 以这种方式实现您的功能

function foo<T, V>(...[t, v]: Parameters<Foo<T, V>>): ReturnType<Foo<T, V>> {
  return [t, v]; // [T, V]
}

正常调用你的函数，或者使用ReturnType获取返回类型

foo(1, 'a') // [number, string]
type Test = ReturnType<Foo<number, number>> // [number, number]