Question

Typescript可以根据您在if语句中询问的值来推断值的类型。例如，可以根据另一个对象来推断一个对象：

type ChildType = 'a' | 'b';

type Child<T extends ChildType> = T extends 'a' ? { type: 'a', color: 'blue' } : T extends 'b' ? { type: 'b', color: 'red' } : never;

interface Parent<T extends Child<ChildType>> {
    child: T extends Child<infer R> ? Child<R> : never;
}


function test<T extends Parent<Child<any>>>(parent: T) {
    if (parent.child.type === 'a') {
        parent.child.color === 'red'; // complains because should be blue
    }
}

但是，使用类型的嵌套成员执行相同的检查，似乎并没有提供相同的效果。

type ChildType = 'a' | 'b';

interface BaseParent<T extends Child<ChildType>> {
    child: T;
}

interface Child<T extends ChildType> {
    type: T;
}

type Parent<T extends ChildType>
    = T extends 'a' ? { color: 'blue' } & BaseParent<Child<'a'>>
    : T extends 'b' ? { color: 'red', opacity: 2 } & BaseParent<Child<'b'>>
    : never;

function test<T extends Parent<ChildType>>(parent: T) {
    if (parent.child.type === 'a') {
        parent.color === 'red' // should complain, but doesn't
    }
}

使用类型保护可以很容易地解决这个问题，但是我正在寻找一种在没有它们的情况下执行此操作的方法。

Answer 1

第一件事-依赖于父数据的子数据可能不是正确的体系结构。依赖关系应该下降。您可以首先考虑它。

但是，如果您愿意，我会做类似的事情（我添加了动物示例以使我更容易理解）：


type AcceptedAnimal = 'dogs' | 'cats';

interface ParentBase {
  accepts: AcceptedAnimal
}

interface Cat {
  meows: boolean;
}

interface Dog {
  race: string;
}

type Parent = DogOwner | CatOwner;

interface DogOwner extends ParentBase {
  animal: Dog
}

interface CatOwner extends ParentBase {
  animal: Cat;
}

function isDogOwner(parent: ParentBase): parent is DogOwner {
  return parent.accepts === 'dogs';
} 

function test(parent: Parent) {
  if (isDogOwner(parent)) {
    parent.animal.race; // ok
    return;
  }

  parent.animal.meows; // ok;
}

Typescript根据嵌套成员推断父类型

1 个答案: