在通用函数中将参数回调签名推断为元组？

Question

从a previous question of mine开始，我希望将作为参数的通用参数类型的映射转发为作为参数传递的回调。我的愿望是传递任意数量的构造函数，使用这些构造函数构造实例，然后将实例转发给回调。

我目前正在执行此操作，其中参数只是回调的数组，但是在语法上不方便，并且TypeScript在验证提供的回调具有正确签名方面也没有提供任何工具帮助。如果您看下面的代码，您应该会明白我的意图。我希望能够为回调（而不是数组）指定常规参数，并且如果回调具有不兼容的签名，则会出现TypeScript错误。

TypeScript可以这样做吗？如果可以，怎么办？

class Component {}
class One extends Component { public a = 1; }
class Two extends Component { public b = 2; }

type CompCon = new (...args: any) => Component;

function receive(one: One, two: Two) { console.log(`one: ${one.a}, two: ${two.b}`) }
function wrongReceive(a: string, b: number) { console.log(`a: ${a}, b: ${b}`) }

function example<T extends Array<CompCon>>(
  callback: (...args: ???) => void,
  ...constructors: T
): void {
  let instances = constructors.map( (c: CompCon) => new c() );
  callback(...instances);
}

example(receive, One, Two); // should be ok
example(wrongReceive, One, Two); // should have typescript compile errors on wrongReceive having wrong signature
example((c: One, d: Two) => {  // should be ok
  console.log(`c: ${c.a}, d: ${d.b}`);
});

Answer 1

您可以这样做。定义Ctor：

type Ctor<C> = new (...args: any[]) => C;

Ctor<C>是一种“可以用new调用并构造C的东西”的类型

然后您可以定义CtorsOf：

type CtorsOf<T> = { [K in keyof T]: Ctor<T[K]> };

如果T是类型的元组，则CtorsOf<T>会生成一个元组，该元组期望每种T类型的构造函数。例如。 CtorsOf<[One, Two]>将解析为[Ctor<One>, Ctor<Two>]。

然后您可以像这样定义example：

function example<C extends Component[]>(
  callback: (...args: C) => void,
  ...constructors: CtorsOf<C>
): void {
  let instances = constructors.map(c => new c()) as C;
  callback(...instances);
}

C是一个元组，定义了您希望在回调中使用的参数的类型，然后从该元组中派生出...constructors参数的构造函数的元组。

我没有办法避免let instances = ... as C中的类型声明。那里的问题是constructors的元组会通过.map操作丢失，并且结果数组的类型为Component[]。我尝试了一些变体，但是即使使用了([1, "2"] as [number, string]).map(x => x);这样的琐碎内容，原始数组的元组也会丢失，TS会为生成的(string | number)[]数组推断出最终类型。

以下是从您的原始来源改编而成的完整示例：

class Component {}
class One extends Component { public a = 1; }
class Two extends Component { public b = 2; }

function receive(one: One, two: Two) { console.log(`one: ${one.a}, two: ${two.b}`) }
function wrongReceive(a: string, b: number) { console.log(`a: ${a}, b: ${b}`) }

// Ctor<C> is a type for "something which can be called with new and constructs a C"
type Ctor<C> = new (...args: any[]) => C;

// Given T a tuple of types, CtorsOf<T> produces a tuple which expects a constructor
// for each type of T. Eg. CtorsOf<[One, Two]> would be [Ctor<One>, Ctor<Two>]
type CtorsOf<T> = { [K in keyof T]: Ctor<T[K]> };

// If you uncomment this and use an editor that shows you what Q expands to, you'll see that
// it expands to [Ctor<One>, Ctor<Two>].
// type Q = CtorsOf<[One, Two]>;

function example<C extends Component[]>(
  callback: (...args: C) => void,
  ...constructors: CtorsOf<C>
): void {
  let instances = constructors.map(c => new c()) as C;
  callback(...instances);
}

example(receive, One, Two); // This is okay.
example((c: One, d: Two) => {  // This is okay.
  console.log(`c: ${c.a}, d: ${d.b}`);
}, One, Two);
// example(wrongReceive, One, Two); // Fails to compile.
// example(receive, Two, One); // Fails to compile.

class TwoPrime extends Two { public bPrime = 1; };

example(receive, One, TwoPrime); // This is okay too. TwoPrime is a subclass of Two.

function receivePrime(one: One, two: TwoPrime) { console.log(`one: ${one.a}, two: ${two.b}`) }

example(receivePrime, One, TwoPrime); // This is okay.
// example(receivePrime, One, Two); // Fails to compile. The shape of Two is not compatible with TwoPrime.

const z = ([1, "2"] as [number, string]).map(x => x);