Question

我遇到一种情况，我想拥有一个可以接受任意数量的泛型对象的args的函数。

我希望结果返回一个元组，其中该对象的每个泛型参数都是元组位置类型。

示例

type Wrap<T> = {
    obj: T;
}

function UnWrap<T extends Array<Wrap<One|Two>>>(...args:T){ //return type?
    return args.map(i => i.obj);
}

type One = {
    foo: string;
}

type Two = {
    bar: string;
}

let one: Wrap<One> = {obj: {foo: 'abc'}}

let two: Wrap<Two> ={obj: {bar: 'abc'}}

// res type should be [One, Two, Two, One]
let res = UnWrap(one, two, two, one)

如果我只返回传入的确切类型，我就可以使用该类型。

function ReturnSelf<T extends Array<Wrap<One|Two>>>(...args:T): typeof args{
    return args;
}

但是我不确定如何索引['obj']类型。我认为也许可以使用映射类型来做到这一点，但我不太清楚。

Typescript Playground link

Answer 1

是的，自TypeScript 3.1引入the ability to map tuple/array types以来，您就可以使用映射类型来执行此操作。您可以像以前那样以“转发”方式进行操作：

function UnWrap<T extends Array<Wrap<One | Two | Three>>>(...args: T) {
  return args.map(i => i.obj) as {
    [K in keyof T]: T[K] extends Wrap<infer U> ? U : never
  };
}

let res2 = UnWrap(one, two, three, two); // [One, Two, Three, Two]

或使用inference from mapped types的“反向”方式：

function UnWrap2<T extends Array<One | Two | Three>>(
  ...args: { [K in keyof T]: Wrap<T[K]> }
) {
  return args.map(i => i.obj) as T;
}
let res3 = UnWrap2(one, two, three, two); // [One, Two, Three, Two]

无论哪种方法都可以工作，正如您所看到的……，无论哪种方式，编译器都无法理解args.map(i => i.obj)会执行您正在执行的类型操作，因此您需要使用type assertion或与之等效（例如使用单个overload签名）。

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

Link to code

将... args映射到子类型的元组

1 个答案: