TypeScript：将“in”运算符定义为函数

Question

我想创建一个行为与in 运算符完全相同的函数，其中使用user-defined type guards 缩小类型。

（例如，请参阅Lodash's has function。）

对于 n in x 表达式，其中 n 是字符串文字或字符串文字类型，x 是联合类型，“true”分支缩小为具有可选或必需属性 n 的类型，“false”分支缩小具有可选或缺失属性 n 的类型。

https://www.typescriptlang.org/docs/handbook/advanced-types.html#using-the-in-operator

我编写了一些测试，展示了 in 运算符的行为以及我们的 has 函数的预期行为。如何定义一个函数 (has) 使其行为与这些测试中的 in 运算符完全相同？

declare const any: any;

type Record = { foo: string; fooOptional?: string };
type Union = { foo: string; fooOptional?: string } | { bar: number; barOptional?: string };

{
  const record: Record = any;

  if ('foo' in record) {
    record; // $ExpectType Record
  } else {
    record; // $ExpectType never
  }

  if (has(record, 'foo')) {
    record; // $ExpectType Record
  } else {
    record; // $ExpectType never
  }
}

{
  const union: Union = any;

  if ('foo' in union) {
    union; // $ExpectType { foo: string; fooOptional?: string | undefined; }
  } else {
    union; // $ExpectType { bar: number; barOptional?: string | undefined; }
  }

  if (has(union, 'foo')) {
    union; // $ExpectType { foo: string; fooOptional?: string | undefined; }
  } else {
    union; // $ExpectType { bar: number; barOptional?: string | undefined; }
  }
}

{
  const unionWithOptional: { foo: string } | { bar?: number } = any;

  if ('bar' in unionWithOptional) {
    unionWithOptional; // $ExpectType { bar?: number | undefined; }
  } else {
    unionWithOptional; // $ExpectType { foo: string; } | { bar?: number | undefined; }
  }

  if (has(unionWithOptional, 'bar')) {
    unionWithOptional; // $ExpectType { bar?: number | undefined; }
  } else {
    unionWithOptional; // $ExpectType { foo: string; } | { bar?: number | undefined; }
  }
}

我最接近解决这个问题的是with this：

type Discriminate<U, K extends PropertyKey> = U extends any
  ? K extends keyof U
    ? U
    : U & Record<K, unknown>
  : never;

export const has = <T extends object, K extends PropertyKey>(
  source: T,
  property: K,
): source is Discriminate<T, K> =>
  property in source;

不幸的是，最后一次测试没有通过。

对于上下文，我想这样做的原因是我的自定义 has 函数可以在编译时验证键（in 运算符不这样做）。我可以弄清楚这部分——我正在努力解决的部分只是模仿in 进行的缩小。

Answer 1

如果没有one-sided or fine-grained type guards 支持守卫真假双方的独立行为，目前是不可能的。

---

您要求的是采用联合类型 { foo: string } | { bar?: number } 并提出用户定义的类型保护，其中真分支将其缩小为 { bar?: number }，而假分支将其保留为完整联合 @987654326 @。

阅读编译器的类型检查器checker.ts的第19788到19809行中的getNarrowedType()函数，我认为这不可能发生。

现在，将(x: any) => x is G 类型的用户定义类型保护应用于union 类型T 的值，编译器当前将分区 联合type 用于类型保护的真分支和假分支。所以在真分支中你会得到类似Extract<T, G>的东西，在假分支中你会得到类似Exclude<T, G>的东西。如果一个联合成员存在于真分支中，它将不存在于假分支中，反之亦然。

只有当T 不是联合类型时 真分支和假分支缩小才可能不相互排斥（有时你会得到真分支的T & G并且只是 T 用于错误分支）。

这是not perfect，但它就是这样。

---

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

Answer 2

has 函数的编写方式可以缩小其参数的类型，至少在键是可选的并且可以缩小为非可选的情况下：

function has<T,K extends keyof T>(obj: T, key: K):
    obj is T & Record<K, Exclude<T[K], undefined>>
{
    return obj[key] !== undefined;
}

type Example = { a: number, b?: number };
let obj: Example = { a: 1, b: 2 };

// inferred obj.b : number|undefined

if(has(obj, 'b')) {
    // inferred obj.b : number
}

但是，您对 Union 类型的要求并不合理。考虑这个例子：

type UnsoundUnion = { a: number, b: number } | { c: number, d: number };

let u: UnsoundUnion = { a: 1, c: 2, d: 3 };

if(has(u, 'a')) {
    // it would be wrong to infer u.b : number
}