强制 Typescript 对象只有一组中的一个键

Question

基本问题和背景

我正在尝试键入一个对象数组，其中每个对象都具有一组中的一个键。例如：

const foo = [
  { a: 'foo' },
  { b: 'bar' },
  { c: 'baz' },
]

我的第一次尝试是key in 一个联合：

type Foo = { [key in 'a' | 'b' | 'c']: string }[]
const foo: Foo = [
  { a: 'foo' },
  { b: 'bar' },
  { c: 'baz' },
]

这不起作用，因为 Typescript 希望 每个 对象在联合中拥有 所有 键：

type Foo = { [key in 'a' | 'b' | 'c']: string }[]
const foo: Foo = [
  { a: 'foo', b: 'bar', c: 'baz' },
  { a: 'foo', b: 'bar', c: 'baz' },
  { a: 'foo', b: 'bar', c: 'baz' },
]

我的第二次尝试是：

type A = { a: string }
type B = { b: string }
type C = { c: string }
type Foo = (A | B | C)[]
const foo: Foo = [
  { a: 'foo' },
  { b: 'bar' },
  { c: 'baz' },
]

但是，作为jcalz points out，仍然允许：

const foo: Foo = [{ a: 'foo', b: 'bar' }]

有没有办法强制每个对象只有一个键并且该键是a 或 b 或 c？

更多上下文

我们的项目正在尝试读取this JSON 来处理 React 中不同国家的地址字段的动态表单。当 Typescript 读取 JSON blob 时，大多数事情都会出错。最重要的是，它认为 fields 键并不总是一个数组，因此不会让我 .map 超过它。所以我决定将 JSON blob 复制到我们的项目中并手动输入。我试图捕捉fields 数组是thoroughfare、premise 或locality 的对象数组，而locality 是localityname 的对象数组等。

Answer 1

如果你想要一个类型，恰好需要一个键，你可以（大部分）将其表示为对象类型的联合，其中联合的每个成员都定义了一个键，其余的键作为可选和the never type。 （实际上，这也将允许undefined，请参阅ms/TS#13195，除非您使用不属于--strict 套件的the --exactOptionalPropertyTypes compiler option。

所以你的Foo 应该是这样的：

type Foo = Array<
  { a: string; b?: never; c?: never; } | 
  { a?: never; b: string; c?: never; } |
  { a?: never; b?: never; c: string; }
>

我们如何以编程方式获得它或类似的东西？好吧，解释起来有点棘手，但我的解决方案如下所示：

type ExactlyOneKey<K extends keyof any, V, KK extends keyof any = K> =
  { [P in K]: { [Q in P]: V } &
    { [Q in Exclude<KK, P>]?: never} extends infer O ?
    { [Q in keyof O]: O[Q] } : never
  }[K];

type Foo = Array<ExactlyOneKey<"a" | "b" | "c", string>>;

ExactlyOneKey<K, V> 类型采用键联合 K 并对其进行迭代。对于联合的每个成员P，它会创建一个对象类型，其中该键存在而其他键不存在/缺失。 {[Q in P]: V}（又名Record<P, V>）类型具有当前键和值，{[Q in Exclude<KK, P>]?: never} 类型具有所有其余键作为可选且从不。我们将它们与& 相交以获得具有这两种特征的类型。然后我做了一个小技巧，... extends infer O ? { [Q in keyof O]: O[Q] } : never 将采用... 类型并将所有交叉点合并为一个对象类型。这不是绝对必要的，但它会将{a: string} & {b?: never, c?: never} 更改为更可口的{a: string; b?: never; c?: never;}。

让我们确保它有效：

const foo: Foo = [
  { a: 'foo' },
  { b: 'bar' },
  { c: 'baz' },
]; // okay

const badFoo: Foo = [
  { d: "nope" }, // error
  { a: "okay", b: "oops" }  // error
];

看起来不错。

Playground link to code

Answer 2

this answer 适合您吗？

type OneKey<K extends string, V = any> = {
    [P in K]: (Record<P, V> &
        Partial<Record<Exclude<K, P>, never>>) extends infer O
        ? { [Q in keyof O]: O[Q] }
        : never
}[K]; //CREDITS TO JCALZ

type Foo = Array<OneKey<'a' | 'b' | 'c', string>>;

const foo: Foo = [
    { a: 'foo' },
    { b: 'bar' },
    { c: 'baz' },
]; //OK

const foo2: Foo = [
    { a: 'foo', b: 'bar', c: 'baz' },
    { a: 'foo', b: 'bar', c: 'baz' },
    { a: 'foo', b: 'bar', c: 'baz' },
]; //NOPE

const foo3: Foo = [{ a: 'foo', b: 'bar' }]; //NOPE