Question

让我们说我正在处理与以下界面相对应的对象：

interface Foo {
    getCount(): number;
    doSomething(): boolean;
}

它只有函数，没有任何函数是异步的。但是，我并不总是对对象进行同步访问，并且在某些情况下将处理异步版本，其中所有函数返回值都包含在Promises中。像这样：

interface AsyncFoo {
    getCount(): Promise<number>;
    doSomething(): Promise<boolean>;
}

我试图创建一个Typescript映射类型来表示这种转换，因为我有大量的对象接口，并且不想简单地复制每个接口并最终同时使用interface [name]和interface Async[name]和所有方法原型重复。

我的第一个想法是，也许我可以修改这样的界面：

type Self<T> = T;
interface Foo<S = Self> {
    getCount(): S<number>;
    doSomething(): S<boolean;
}
type AsyncFoo = Foo<Promise>;

但是Self和Promise都要求在使用泛型时静态地给出泛型，而不是以这种向后的方式使用它们。

接下来我尝试创建某种映射类型，例如：

type Promisify<T> = {[K in keyof T]: Promise<T[K]>}

但是当然这会将接口的每个整个方法包装在Promise中，而不仅仅是返回值，这给了我：

type PromisifiedFoo = {
    getCount: Promise<() => number>;
    doSomething: Promise<() => boolean>;
}

我试图通过对T Promisify的通用type Promisify<T extends {[key: string]: <S>() => S}> = ...使用范围来扩展此功能，如：

gem 'pg', '0.21.0'

但我似乎无法将它们融合在一起。

所以我现在在这里。有没有办法让我建立一个代表这个＆＃34; Promisify＆＃34;的类型（映射或其他）？转换到类型的返回值？

Answer 1

使用Typescript 2.8中的新Conditional Types，您可以执行以下操作：

// Generic Function definition
type AnyFunction = (...args: any[]) => any;
// Extracts the type if wrapped by a Promise
type Unpacked<T> = T extends Promise<infer U> ? U : T;

type PromisifiedFunction<T extends AnyFunction> =
    T extends () => infer U ? () => Promise<Unpacked<U>> :
    T extends (a1: infer A1) => infer U ? (a1: A1) => Promise<Unpacked<U>> :
    T extends (a1: infer A1, a2: infer A2) => infer U ? (a1: A1, a2: A2) => Promise<Unpacked<U>> :
    T extends (a1: infer A1, a2: infer A2, a3: infer A3) => infer U ? (a1: A1, a2: A2, a3: A3) => Promise<Unpacked<U>> :
    // ...
    T extends (...args: any[]) => infer U ? (...args: any[]) => Promise<Unpacked<U>> : T;

type Promisified<T> = {
    [K in keyof T]: T[K] extends AnyFunction ? PromisifiedFunction<T[K]> : never
}

示例：

interface HelloService { /** * Greets the given name * @param name */ greet(name: string): string; } function createRemoteService<T>(): Promisified<T> { /*...*/ } const hello = createRemoteService<HelloService>(); // typeof hello = Promisified<HelloService> hello.greet("world").then(str => { /*...*/ }) // typeof hello.greet = (a1: string) => Promise<string>

Answer 2

攻击此方法的一种方法是制作Foo的通用版本，该版本可以专门用于同步版本或异步版本。

type MaybePromise<T, B extends 'plain' | 'promise'> = { 
  plain: T, 
  promise: Promise<T> 
}[B]

类型MaybePromise<T,'plain'>等于T，MaybePromise<T, 'promise'>等于Promise<T>。现在，您可以描述通用Foo：

type GenericFoo<B extends 'plain' | 'promise'> = {
  getCount(): MaybePromise<number, B>;
  doSomething(): MaybePromise<boolean, B>;
}

最后把它专门化：

interface Foo extends GenericFoo<'plain'> { }
interface AsyncFoo extends GenericFoo<'promise'> { }

这应该符合您的预期：

declare const f: Foo;
if (f.doSomething()) {
  console.log(2 + f.getCount());
}

declare const aF: AsyncFoo; 
aF.doSomething().then(b => {
  if (b) {
    aF.getCount().then(n => {
      console.log(2 + n);
    })
  }
});

希望有所帮助。祝你好运！

创建映射类型以使promisify返回值

2 个答案: