用自己的“更多”正确覆盖固有类型 - 打字稿

Question

我有一个函数返回一个将使用反射解决的承诺。

（Promise with、resolve 和 reject 函数排队然后执行）

函数的输入是来自一个对象的方法，参数如 SingleTask 类型所示。

因为我没有在承诺打字稿中返回任何内容，所以将Promise<any> 作为结果。

但实际上，结果是 Promise<FIRST PARAM OF SINGLE TASK TYPE>> - Some function from an object

如何声明正确的返回类型

type AnyClass = { new (...arg0: any): any }

type SingleTask<V extends AnyClass> = {
  [P in keyof InstanceType<V>]-?: InstanceType<V>[P] extends (...a: any) => any
    ? [P, Parameters<InstanceType<V>[P]>]
    : never
}[keyof InstanceType<V>]

  addTaskToQueue(task: SingleTask<T>): Promise<ReturnType<**What i should put here ?** >> {
    return new Promise((resolve, reject) => {
      const instance = this.instances.pop()
      if (instance) {
        this.runTasksInQueue(instance, { task, resolve, reject })
      } else {
        this.queue.push({ task, resolve, reject })
      }
    })
  }

Typescript playground with full code

Answer 1

我假设你想要这种行为：

type SomeCtor = new () => { a(x: string, y: number): boolean, b(z: number): string }
declare const q: Queue<SomeCtor>;
const a = q.addTaskToQueue(["a", ["", 1]]); // Promise<boolean>;
const b = q.addTaskToQueue(["b", [1]]); // Promise<string>;

我也只会担心addTaskToQueue() 的类型签名，而不是您的实现以及实现如何与签名交互。从类型系统的角度来看，根据您定义的类型，我会做这样的事情：

declare class Queue<T extends AnyClass> {
  addTaskToQueue<S extends SingleTask<T>>(task: S): Promise<ReturnType<InstanceType<T>[S[0]]>>;
}

addTaskToQueue() 方法必须是泛型的，否则最好的办法是获取另一个联合作为返回类型，对应于整个 SingleTask<T> 联合。您希望返回类型取决于传入的SingleTask<T> 联合的哪个 成员。一旦我们有一个类型参数S 对应于SingleTask<T> 的某个成员，我们就可以表示返回输入为

Promise<ReturnType<InstanceType<T>[S[0]]>>

请注意，S[0] 将是传入的InstanceType<T> 的键，因此我们正在查找该属性。您可以验证这是否为您提供了我认为您想要的行为。

这就是问题的答案。

---

顺便说一句，尚不清楚为什么您的泛型T 是您总是使用InstanceType<T> 处理的构造函数类型。看起来你对T 类型的对象所做的唯一事情是调用new this.object()，它特别假设构造函数采用零参数。如果是这样，我建议将T 更改为实例类型本身，并将构造函数称为new()=>T 类型：

type SingleTask<T> = {
  [P in keyof T]-?: T[P] extends (...a: any) => any
  ? [P, Parameters<T[P]>]
  : never
}[keyof T]

type Task<T> = {
  task: SingleTask<T>
  resolve: (value?: unknown) => void
  reject: (reason: any) => void
}

declare class Queue<T> {
  instances: T[];
  queue: Task<T>[];
  object: new () => T;
  addTaskToQueue<S extends SingleTask<T>>(task: S): Promise<ReturnType<T[S[0]]>>;
}

type SomeType = { a(x: string, y: number): boolean, b(z: number): string }
declare const q: Queue<SomeType>;
const a = q.addTaskToQueue(["a", ["", 1]]); // Promise<boolean>;
const b = q.addTaskToQueue(["b", [1]]); // Promise<string>;

这要简单得多。

Playground link to code