通用函数的 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

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

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 2

这是我目前用于提取未导出的内部类型的导入库（如 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 3

如果您可以更改函数定义，我找到了一种很好且简单的方法来实现这一点。 就我而言，我需要将 typescript 类型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

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

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

Answer 5

我找到了解决方案。 您决定它是否适合您的需求:)

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

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]

Answer 6

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

但是，TypeScript 具有可调用接口，这些接口可以是通用的，没有任何问题，因此如果您引入与函数签名兼容的可调用接口，则可以像这样实现自己的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