TypeScript中的可变参数泛型类型？

Question

I'd like to make a function in TypeScript that takes an array of constructor functions and returns a corresponding array of instances. See code below.

Note that the getArray method is wildly incorrect, it is just an attempt to convey my intent.

Is this possible in any form or is it beyond the capabilities of TypeScript's type engine?

class T1 {}
class T2 {}
class T3 {}
type AnyCon = new() => any;

function getOne<T_Con extends AnyCon>(con: T_Con): InstanceType<T_Con> {
  return new con();
}

function getArray<T_Cons>(cons: T_Cons): InstanceType<T_Cons>[] {
  return cons.map( (c: con) => new con() );
}

let t1: T1 = getOne(T1);
let [t2, t3]: [T2, T3] = getArray( [T2, T3] );

Answer 1

You can do this in TS3.1 and above using mapped array/tuple types . It's easier to get tuples inferred for rest parameters than it is for array parameters, so I'll show that instead:

function getVariadic<T extends Array<AnyCon>>(...cons: T): {
  [K in keyof T]: T[K] extends AnyCon ? InstanceType<T[K]> : never
};
function getVariadic(...cons: AnyCon[]): any[] {
  return cons.map((c: AnyCon) => new c());
}

let [t2, t3]: [T2, T3] = getVariadic(T2, T3);

This behaves as you expect, I think. Hope that helps. Good luck!

---

EDIT: if you really need to do it with an array it's easy to type the function but a little harder to call it in such a way that the order of the array is preserved as a tuple:

function getArray<T extends Array<AnyCon>>(cons: T): {
  [K in keyof T]: T[K] extends AnyCon ? InstanceType<T[K]> : never
};
function getArray(cons: AnyCon[]): any[] {
  return cons.map((c: AnyCon) => new c());
}

// error, getArray([T2, T3]) returns (T2 | T3)[]!
let [t2, t3]: [T2, T3] = getArray([T2, T3]); // 🙁

Oops let's try again

// okay, but verbose and redundant
let [t2, t3]: [T2, T3] = getArray([T2, T3] as [typeof T2, typeof T3]); // 😐

Well maybe we can use a helper function to get [T2, T3] inferred as a tuple type:

// put this in a library somewhere
type Lit = string | number | boolean | undefined | null | void | {};
const tuple = <T extends Lit[]>(...args: T) => args;

// works! but now is very similar to getVariadic
let [t2, t3]: [T2, T3] = getArray(tuple(T2, T3)); 🙂

Finally, once TypeScript 3.4 lands there will be const contexts which are a bit easier but require some more changes to getArray() :

// note the widening to ReadonlyArray
function getArray<T extends ReadonlyArray<AnyCon>>(cons: T): {
  -readonly [K in keyof T]: T[K] extends AnyCon ? InstanceType<T[K]> : never
};
function getArray(cons: AnyCon[]): any[] {
  return cons.map((c: AnyCon) => new c());
}

// works and is the least repetitive
let [t2, t3]: [T2, T3] = getArray([T2, T3] as const); 😀

But as I said above, getVariadic() is probably the most straightforward way to get this behavior right now.