Typescript 不能正确推断类型

Question

class A {
    readonly is_prop: boolean;
    constructor(is_prop: boolean) {
        this.is_prop = is_prop;
    }
}

class B {
    readonly my_prop: boolean;
    constructor(my_prop: boolean) {
        this.my_prop = my_prop;
    }
}

type A1 = A & {is_prop: true};
type A2 = A & {is_prop: false};

type C = A1 | A2 | B;

const a: A = new A(true);
const b: A = new A(false);
const c: B = new B(true);

const e: A1 | null = a.is_prop ? a : null;

In the above example, why is the assignment for e giving error? Why is TS not inferring that is_prop will be true

Typescript playground

Answer 1

The error is because a is of type A :

const a: A = new A(true);

In the ternary, you check that is_prop is true , but the variable a is still of type A . The property has been narrowed to true , but a hasn't changed types. As an example, this code would be valid based on your narrowing:

const trueVal: true | null = a.is_prop ? a.is_prop : null 

If you want to be able to narrow the type of a , you need to say that it can be one of several types by stating that it's a union:

const a: A1|A2 = new A(true);

playground with some more alternatives.

Answer 2

You get that error because of this line of code

type A1 = A & {is_prop: true}; //for class a, is_prop is boolean

boolean is not a subset of true, so you can't assign class A to type A1:

you could try this:

type A1 = A & {is_prop: boolean};

or this:

const e: A1 | null = a.is_prop ? a as A1: null;

Answer 3

That's because that true doesn't equal boolean type

And I don't think you need to declare type of the variables ab c again

They can be directly implicitly declared through the following generics .

class A<T = boolean> {
  readonly is_prop: T extends boolean ? T : never;
  constructor(is_prop: T extends boolean ? T : never) {
    this.is_prop = is_prop;
  }
}

class B {
  readonly my_prop: boolean;
  constructor(my_prop: boolean) {
    this.my_prop = my_prop;
  }
}

type A1 = A & { is_prop: true };
type A2 = A & { is_prop: false };

type C = A1 | A2 | B;

const a = new A(true);
const b = new A(false);
const c = new B(true);

const e: A1 | null = a.is_prop ? a : null;

In this way, you don't have to declare type A1 A2 C and declare type A1 | null A1 | null to e , and then you can get more simplified code like that

class A<T = boolean> {
  readonly is_prop: T extends boolean ? T : never;
  constructor(is_prop: T extends boolean ? T : never) {
    this.is_prop = is_prop;
  }
}

class B {
  readonly my_prop: boolean;
  constructor(my_prop: boolean) {
    this.my_prop = my_prop;
  }
}

const a = new A(true);
const b = new A(false);
const c = new B(true);

const e = a.is_prop ? a : null;