TypeScript 中的联合类型类型推断

huangapple
go评论98阅读模式
英文:

Type inference with union types in TypeScript

问题

我有一个类型C，它是A和B类型的联合。我有一个类型C的变量，在分配了B类型之后，似乎类型推断在B和C具有相同名称的属性时不起作用。

  1. class A {
  2.     prop1: string;
  3. }
  5. class B {
  6.     prop1: string;
  7.     prop2: string;
  8. }
  10. type C = A | B;
  12. class test {
  13.     thisIsC: C;
  15.     constructor() {
  16.         this.thisIsC = this.getTypeB(); //这不会使thisIsC被推断为B
  17.         const b = this.getTypeB(); //这样可以正常工作
  18.         const a = this.thisIsC;
  19.     }
  21.     getTypeB(): B {
  22.         return new B();
  23.     }
  24. }

如果属性不发生冲突，问题就不会出现，类型推断会正常工作（例如）：

  1. class A {
  2.     prop1: string;
  3. }
  5. class B {
  6.     prop2: string;
  7.     prop3: string;
  8. }
  10. type C = A | B;
  12. class test {
  13.     thisIsC: C;
  15.     constructor() {
  16.         this.thisIsC = this.getTypeB(); //这会使thisIsC被推断为B类型
  17.         const a = this.thisIsC;
  18.     }
  20.     getTypeB(): B {
  21.         return new B();
  22.     }
  23. }

我的问题是，如果我可以做一些改进类型推断的事情（与冲突的参数一起），只是告诉typescript在getTypeB()调用之后变量"thisIsC"是B类型。显然，“如果我们有一个具有联合类型的值，我们只能访问联合中所有类型的公共成员。”这对我来说有道理，但在我的代码中，“getTypeB()”明确返回B类型。我可以通过创建辅助变量或使用类型守卫进行手动类型断言来解决这个问题，但我想知道是否可以做些修改内部工作方式的事情。

Playground上的错误示例：
https://t.ly/iFZ0

提前感谢您的回答。

英文:

I have a type C which is the union of A and B types. I have a variable of type C and after assigning a B type it seems that the type infer is not working when B and C have one property with the same name.

  1. class A {
  2.     prop1: string;
  3. }
  5. class B {
  6.     prop1: string;
  7.     prop2: string;
  8. }
  10. type C = A | B;
  12. class test {
  13.     thisIsC: C;
  15.     constructor() {
  16.         this.thisIsC = this.getTypeB(); //This doesn't make thisIsC inferred to B
  17.         const b = this.getTypeB(); //This works fine
  18.         const a = this.thisIsC;
  19.     }
  21.     getTypeB(): B {
  22.         return new B();
  23.     }
  24. }

If the properties don't collide, the problem doesn't appear and the type infer is done properly (for example):

  1. class A {
  2.     prop1: string;
  3. }
  5. class B {
  6.     prop2: string;
  7.     prop3: string;
  8. }
  10. type C = A | B;
  12. class test {
  13.     thisIsC: C;
  15.     constructor() {
  16.         this.thisIsC = this.getTypeB(); //This makes thisIsC be inferred to B type
  17.         const a = this.thisIsC;
  18.     }
  20.     getTypeB(): B {
  21.         return new B();
  22.     }
  23. }

My question is if I can do something to improve this type inference (with colliding parameters) just to tell typescript that the variable "thisIsC" is of type B after the getTypeB() call. Apparently "If we have a value that has a union type, we can only access members that are common to all types in the union." which makes sense to me, but in my code, "getTypeB()" returns explicitly a type B. I just can solve the problem creating an aux variable or doing a manual type assertion with a type guard but I want to know if I can do anything to modify how this internally works.

Playground with the error:
https://t.ly/iFZ0

Thanks in advance

答案1

得分: 1

Sure, here is the translated text:

> 我想知道我是否可以做任何修改内部工作方式的事情。

我建议对你的 A 和 B 类型进行 标记。

  1. class A {
  2.     prop1: string;
  3.     tag: "A";
  5.     constructor() {
  6.         this.prop1 = "helloworld";
  7.         this.tag = "A";
  8.     }
  9. }
  11. class B {
  12.     prop1: string;
  13.     prop2: string;
  14.     tag: "B";
  16.     constructor() {
  17.         this.prop1 = "helloworld";
  18.         this.prop2 = "prop2";
  19.         this.tag = "B";
  20.     }
  21. }
  23. type C = A | B;
  25. class test {
  26.     thisIsC: C;
  28.     constructor() {
  29.         this.thisIsC = this.getTypeB();
  30.         const b = this.thisIsC;
  32.         b.prop2;
  33.     }
  35.     getTypeB(): B {
  36.         return new B();
  37.     }
  38. }

在对它们进行标记之后，TypeScript 能够正确地推断类型。

play

英文:

> I want to know if I can do anything to modify how this internally works.

I would recommend tagging your A and B types.

  1. class A {
  2.     prop1: string;
  3.     tag: "A";
  5.     constructor() {
  6.         this.prop1 = "helloworld";
  7.         this.tag = "A"
  8.     }
  9. }
  11. class B {
  12.     prop1: string;
  13.     prop2: string;
  14.     tag: "B";
  16.     constructor() {
  17.         this.prop1 = "helloworld";
  18.         this.prop2 = "prop2";
  19.         this.tag = "B";
  20.     }
  21. }
  23. type C = A | B;
  25. class test {
  26.     thisIsC: C;
  28.     constructor() {
  29.         this.thisIsC = this.getTypeB();
  30.         const b = this.thisIsC;
  32.         b.prop2;
  33.     }
  35.     getTypeB(): B {
  36.         return new B();
  37.     }
  38. }

After tagging them typescript is able to properly infer the types.

play

huangapple
  • 本文由 发表于 2023年6月29日 15:40:22
  • 转载请务必保留本文链接：https://go.coder-hub.com/76578971.html
  • inference
  • typescript
  • typing
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定