5

类似于TypeScript Mapped Types: Get element type of array，我有一个类型，比如：

type A = {
   Item1: Promise<string>,
   Item2: Promise<number>,
   Item3: number
}

我想从中提取以下类型：

type A' = {
   Item1: string,
   Item2: number,
   Item3: number
}

请注意不是 Promise 的字段之一的额外复杂性。

这甚至可能吗，还是我只是达到了打字稿推断类型能力的极限？我试着摆弄映射类型和记录类型，但我就是想不通。

更新：

假设我想对函数调用做同样的事情：

type A = {
  Item1: (string, number) => Promise<string>,
  Item2: () => Promise<number>,
  Item3: () => number
}

所需的类型是：

type A' = {
  Item1: (string, number) => string,
  Item2: () => number,
  Item3: () => number
}

我认为这与我陈述的第一种情况足够相似，但函数返回值似乎并不像我希望的那样简单。

4

2 回答 2

9

更新 2020-01-28

由于 TypeScript 2.8 引入了条件类型，您现在可以相对轻松地进行此映射：

type A = {
  Item1: (x: string, y: number) => Promise<string>,
  Item2: () => Promise<number>,
  Item3: () => number,
  Item4: Promise<string>,
  Item5: Promise<number>,
  Item6: number
}

type UnpromiseObj<T> = { [K in keyof T]: T[K] extends Promise<infer U> ? U :
  T[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R :
  T[K]
}

type Aprime = UnpromiseObj<A>;
/* type Aprime = {
  Item1: (x: string, y: number) => string;
  Item2: () => number;
  Item3: () => number;
  Item4: string;
  Item5: number;
  Item6: number;
} */

我将留下以下内容，以便为后代保留在条件类型存在之前必须经历的疯狂废话：

结束更新 2020-01-28

这并非完全不可能，但如果没有对映射条件类型等的官方支持，它就很不稳定。咱们试试吧。首先，让我们设置一些类型级别的布尔逻辑：

type False = '0';
type True = '1';
type Bool = False | True;
type If<Cond extends Bool, Then, Else> = { '0': Else; '1': Then }[Cond];

所以类型If<True, Then, Else>评估为Then，类型If<False, Then, Else>评估为Else。

第一个问题是您需要能够确定类型是否为 a Promise。第二个是你需要能够得到 的类型T，给定 a Promise<T>。我将通过使用一些在运行时不存在的虚拟属性来增加Object和接口的声明来做到这一点：Promise<T>

// if you are in a module you need to surround 
// the following section with "declare global {}"
interface Object {
  "**IsPromise**": False
}
interface Promise<T> {
  "**IsPromise**": True
  "**PromiseType**": T
}

那是不确定的部分。增加全局接口并不是很好，因为它们在每个人的命名空间中。但它具有所需的行为：任何Object不是 a 的Promise都有False其"**IsPromise**"属性的类型，并且 aPromise有一个True值。此外， aPromise<T>具有"**PromiseType**"type 的属性T。同样，这些属性在运行时不存在，它们只是为了帮助编译器。

现在我们可以定义Unpromise将 a 映射Promise<T>到哪些T类型并且不考虑任何其他类型：

type Unpromise<T extends any> = If<T['**IsPromise**'], T['**PromiseType**'], T>

并MapUnpromise映射Unpromise到对象的属性：

type MapUnpromise<T> = {
  [K in keyof T]: Unpromise<T[K]>
}

让我们看看它是否有效：

type A = {
   Item1: Promise<string>,
   Item2: Promise<number>,
   Item3: number
}
    
type Aprime = MapUnpromise<A>
// evaluates to { Item1: string; Item2: number; Item3: number; }

成功！但是我们对类型做了一些相当不愉快的事情来让它发生，这可能不值得。随你（由你决定！

希望有帮助；祝你好运！

更新 1

据我所知，不幸的是，对函数调用做同样的事情是不可能的。你真的需要像扩展typeof类型查询这样的东西，而且它现在还不是 TypeScript 的一部分（无论如何从 TypeScript v2.5 开始）。

因此，您无法获取您的类型A并从中进行计算APrime（请注意，这A'不是有效的标识符。Aʹ如果需要，请使用）。但是您可以创建一个基本类型，您可以从中计算A和APrime：

type False = '0';
type True = '1';
type Bool = False | True;
type If<Cond extends Bool, Then, Else> = { '0': Else; '1': Then }[Cond];
type MaybePromise<Cond extends Bool, T> = If<Cond, Promise<T>, T>

我已经放弃了全局增强并添加了MaybePromise<Cond, T>， whereMaybePromise<True, T>评估为Promise<T>，并MaybePromise<False, T>评估为T。现在我们可以获取A和APrime使用MaybePromise<>：

type ABase<Cond extends Bool> = {
  Item1: (s: string, n: number) => MaybePromise<Cond, string>,
  Item2: () => MaybePromise<Cond, number>,
  Item3: () => number
}

type A = ABase<True>;
// evaluates to { 
//   Item1: (s: string, n: number) => Promise<string>; 
//   Item2: () => Promise<number>; 
//   Item3: () => number; }


type APrime = ABase<False>;
// evaluates to { 
//   Item1: (s: string, n: number) => string; 
//   Item2: () => number; 
//   Item3: () => number; }

所以这行得通！但是我建议的重构可能无法很好地适应您的用例。这首先取决于您如何获取A类型。哦，那是我能做的最好的了。希望它有一些帮助。再次祝你好运！

于 2017-09-21T01:17:13.377 回答
0

Awaited如今使用 TypeScript 4.5 的实用程序类型变得更加容易：

type A = {
  Item1: Promise<string>;
  Item2: Promise<number>;
  Item3: number;
  Item4: (arg0: string, arg1: number) => Promise<string>;
  Item5: () => Promise<number>;
  Item6: () => number;
};

type AwaitValues<T> = {
  [K in keyof T]: T[K] extends (...args: infer P) => infer R
    ? (...args: P) => Awaited<R>
    : Awaited<T[K]>;
};

type A2 = AwaitValues<A>;

通过悬停A2我们可以看到它的类型是：

/*
type A2 = {
    Item1: string;
    Item2: number;
    Item3: number;
    Item4: (arg0: string, arg1: number) => string;
    Item5: () => number;
    Item6: () => number;
}
*/
于 2022-02-10T21:55:00.710 回答