Typescript：具有不同参数的泛型数组

考虑一个这样调用的函数：

func([
   {object: object1, key: someKeyOfObject1},
   {object: object2, key: someKeyOfObject2}
])

它有一个数组。我想强制执行key字段保存所保存对象的键object. 每个物体都可以有不同的形状。

为单个对象构造这样的类型很容易：

type Type<T> = { obj: T, key: keyof T }

但是，我不知道如何从中创建一个数组，其中每个元素都会被强制执行。Type<any>[]会掉落所有类型。

在功能方面限制这一点是很困难的。我什至不认为有通用的方法可以做到这一点。

非泛型解决方案：函数重载

interface Item<TObject> {
  object: TObject
  key: keyof TObject
}

function func<T1, T2, T3, T4>(items: [Item<T1>, Item<T2>, Item<T3>, Item<T4>]): void
function func<T1, T2, T3>(items: [Item<T1>, Item<T2>, Item<T3>]): void
function func<T1, T2>(items: [Item<T1>, Item<T2>]): void
function func<T1>(items: Item<T1>[]): void {

}

func([
  { object: { a: '1' }, key: 'a' },
  { object: { b: '1' }, key: 'b' },
  { object: { c: '1' }, key: 'a' }, // not allowed
])

解决方案 2：在调用方强制执行类型基本上，您依赖效用函数。仍然有办法在这里犯错误并让编译器错过它（请参阅示例中的最后一项）

interface Item<TObject extends object> {
  object: TObject
  key: keyof TObject
}

function func(items: Item<any>[]) {

}

function createItem<T extends object>(object: T, key: keyof T): Item<T> {
  return {
    object,
    key
  }
}

func([
  createItem({ a: 1 }, 'a'),
  createItem({ b: 2 }, 'f'), // not allowed
  { object: { b: 2 }, key: 'f' }, // allowed
])

解决方案 3：使用通用 add 方法创建处理器对象

interface Item<TObject> {
  object: TObject
  key: keyof TObject
}

function createMyArrayProcessor() {
  const array: Item<any>[] = []

  return {
    add<T>(item: Item<T>) {
      array.push(item)

      return this
    },
    result() {
      // process the array here and return the result
    }
  }
}

const result = createMyArrayProcessor()
  .add({ object: { a: '1' }, key: 'a' })
  .add({ object: { b: '1' }, key: 'b' })
  .add({ object: { c: '1' }, key: 'a' }) // not allowed
  .result()