Question

我有2个由常量值初始化的枚举值的二维数组。我想以这种方式指定此数组的类型，不允许将相同的值多次放置在数组中的任何位置。请注意，我不需要使用每个值。

我该怎么办？

const enum Smth {
  a = "a",
  b = "b",
  c = "c",
  d = "d",
}

type Unique2dArray<T> = T[][] // Want to write this type

const x: Unique2dArray<Smth> = [ // Should be valid
  [Smth.a, Smth.b],
  [Smth.d],
]

const y: Unique2dArray<Smth> = [ // Should NOT be valid (Smth.a is repeated)
  [Smth.a, Smth.b, Smth.a],
  [Smth.d],
]

const z: Unique2dArray<Smth> = [ // Should NOT be valid (Smth.a is repeated)
  [Smth.a, Smth.b],
  [Smth.d, Smth.a],
]

Answer 1

我给这个答案，因为它的2d性质有点复杂。基本上与this question的答案中的技术相同：

内联评论：

// BlankOut2D<T, K, L> takes a nested tuple T, and a pair of indices, and
// replaces the value in the tuple with never.
// So BlankOut2D<[['a','b'],['c','d']],'0','1'> is [['a',never],['c','d']].
type BlankOut2D<T extends ReadonlyArray<ReadonlyArray<any>>, K extends keyof T, L extends PropertyKey> = {
  [P in keyof T]: T[P] extends infer TP ? {
    [Q in keyof TP]: [P, Q] extends [K, L] ? never : TP[Q]
  } : never
}

// AppearsIn2d<T, V, Y, N> takes a nested tuple T and a value V, 
// and returns Y if the value V is assignable to any element of any element of T
// and returns N otherwise
type AppearsIn2D<T, V, Y = unknown, N = never> = unknown extends {
  [P in keyof T]: T[P] extends infer TP ? {
    [Q in keyof TP]: V extends TP[Q] ? unknown : never
  }[keyof TP] : never }[keyof T] ? Y : N

// Invalid<T> makes an error message in lieu of custom invalid types 
// (see microsoft/typescript#23689)
type Invalid<T> = Error & { __errorMessage: T };

// UniquifyTwoD<T> takes a 2-d nested tuple T and returns T iff no repeats
// appear, otherwise it replaces offending repeated elements with an Invalid<>
type UniquifyTwoD<T extends ReadonlyArray<ReadonlyArray<any>>> = {
  [P in keyof T]: T[P] extends infer TP ? {
    [Q in keyof TP]: AppearsIn2D<BlankOut2D<T, P, Q>, TP[Q], Invalid<[TP[Q], "is repeated"]>, TP[Q]>
  } : never
}

// helper function
const asUnique2DSmthArray = <
  A extends ([[]] | (ReadonlyArray<ReadonlyArray<Smth>>)) & UniquifyTwoD<A>
>(
  a: A
) => a;

它的工作原理如下：

const x = asUnique2DSmthArray([
  [Smth.a, Smth.b],
  [Smth.d],
]); // okay

const y = asUnique2DSmthArray([
  [Smth.a, Smth.b, Smth.a], // error!
  //~~~~~          ~~~~~~ <-- not assignable to Invalid<[Smth.a, "is repeated"]>
  [Smth.d], 
]); 

const z = asUnique2DSmthArray([
  [Smth.a, Smth.b], // error! 
  //~~~~~ <-- Invalid<[Smth.a, "is repeated"]
  [Smth.d, Smth.a], // error!
  //~~~~~, ~~~~~~ <-- Invalid<[Smth.a | Smth.d, "is repeated"]> ?  
]);

除了重复的元素跨越数组时的错误并不完美之外，几乎所有的工作都有效。问题在于可分配性的失败导致编译器将第二个参数的类型从[Smth.d, Smth.a]扩展到Array<Smth.d | Smth.a>，然后抱怨整个参数被重复。但是我不知道如何防止这种情况发生。

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

Link to code

禁止在阵列中重复

1 个答案: