以类型安全的方式检查对象中的可能属性

Question

TypeScript 2.0 supports tagged unions like this:

type Foo = {
  tag: 'foo'
  x: number
}

type Bar = {
  tag: 'bar'
  y: string
}

type FooOrBar = Foo | Bar

and then we can discriminate between the cases in a typesafe way:

function doStuff(foobar: FooOrBar) {
  if (foobar.tag === 'foo') {
    console.log(foobar.x + 3)
  } else {
    console.log(foobar.y.length)
  }
}

All well and good. But really the tag field isn't strictly necessary in order to distinguish these types. We could conceive of doing this:

type Foo2 = {
  x: number
}

type Bar2 = {
  y: string
}

type Foo2OrBar2 = Foo2 | Bar2

Is there a similar way I can do case analysis on such a union in a typesafe way? The obvious thing doesn't work:

function doStuff2(foobar: Foo2OrBar2) {
  if ('x' in foobar) {
    // Type error: Property 'x' does not exist on type 'Bar2'
    console.log(foobar.x + 5)
  } else {
    // Type error: Property 'y' does not exist on type 'Foo2'
    console.log(foobar.y.length)
  }
}

Is there another way to do it?

Answer 1

I figured out how to do this with a generic type guard :

function hasKey<K extends string>(k: K, o: any): o is { [_ in K]: any } {
  return typeof o === 'object' && k in o
}

Then this works:

function doStuff2(foobar: Foo2OrBar2) {
  if (hasKey('x', foobar)) {
    console.log(foobar.x + 5)
  } else {
    console.log(foobar.y.length)
  }
}

UPDATE

There's a TypeScript ticket for making in perform as a type guard:

https://github.com/Microsoft/TypeScript/issues/10485

Answer 2

You can try something like this:

function doStuff2(foobar: Foo2OrBar2) {
    if ((<Foo2>foobar).x != undefined){         
    console.log((<Foo2>foobar).x + 5)
  } else {
    console.log((<Bar2>foobar).y.length)
  }
}