Question

我有简单的类型，例如：

type A = { a: number }
type B = { b: string }

为模糊性，我有一个带有type的包装器：

type HasType<T> = {
  node: T,
  type: 'a' | 'b',
}

我正在尝试创建一种factory方法，在此方法中，使用以下方法会产生歧义：

function onlyA(obj: A): A { return obj; }
function onlyB(obj: B): B { return obj; }

没有类型，factory可能看起来像这样：

function factory(obj) {
  if (obj.type === 'a') onlyA(obj.node)
  else onlyB(obj.node)
}

所以我尝试了一些事情，

与HasType的联盟：

function factory(obj: HasType<A> | HasType<B>): void {
  if (obj.type === 'a') onlyA(obj.node)
  else onlyB(obj.node)
}

仅结合使用类型，并访问其属性：

function factory2(obj: A | B): void {
  if (obj.a) onlyA(obj)
  else onlyB(obj)
}

仅联盟具有类型，并验证属性是否存在：

function factory3(obj: A | B): void {
  if ('a' in obj) onlyA(obj)
  else onlyB(obj)
}

不幸的是，它们没有用，可以在here中找到示例。

我想念什么吗？我们可以通过其他方式实现这一目标吗？

Answer 1

@zerkms指出的解决方案是，每种类型都具有公共属性，并具有特定值，例如：

type A = { a: number, type: "a" }
type B = { b: string, type: "b" }

function onlyA(obj: A): A { return obj; }
function onlyB(obj: B): B { return obj; }

function factory(obj: A | B): void {
  if (obj.type === 'a') onlyA(obj)
  else onlyB(obj)
}

可以here对此进行测试

如何对流类型进行消歧

1 个答案: