交叉类型

将多个类型合并成为一个新的类型，新类型具有所有类型的特性 场景： 交叉类型具有所有类型的特性，非常适合对象混入的场景 语法： A & B 注意： 交叉类型中的交叉，并不是指两个类型的交集，而是并集

  1. interface DogInterface {
  2.     run(): void;
  3. }
  5. interface CatInterface {
  6.     jump(): void;
  7. }
  9. // 交叉类型：取所以类型的并集
  10. let pet: DogInterface & CatInterface = {
  11.     run() {},
  12.     jump() {},
  13. };

联合类型

简单的联合类型

联合类型：类型可能为多个类型中的一种，但不能确定是哪一种

  1. let strA: number | string = "a";
  2. let strB: "a" | "b" | "c";

字面量联合类型

不仅限定变量类型，还限定变量的取值范围

  1. let strC: 1 | 2 | 3;
  2. let strD: "1" | "2" | "3" = "1";

对象联合类型

  1. // 定义两个类,分别实现两个接口
  2. class Doga implements DogInterface {
  3.     run() {}
  4.     eat() {}
  5. }
  7. class Cata implements CatInterface {
  8.     jump() {}
  9.     eat() {}
  10. }
  12. // 定义枚举 Master
  13. enum Master {
  14.     Boy,
  15.     Girl,
  16. }
  17. // 根据类型获取实例
  18. function getPet(master: Master) {
  19.     let pet = master === Master.Boy ? new Doga() : new Cat();
  20.     pet.eat();
  21.     // pet.run()
  22.     return pet;
  23. }

可区分的联合类型

本质上是结合联合类型和字面量类型的一种类型保护方法 如果一个类型是多个类型的联合类型，且多个类型间有一个公共属性。那么，就可以利用这个公共属性，创建不同的类型保护区块

  1. // 正方形
  2. interface Square {
  3.     kind: "square";
  4.     side: number; // 边长
  5. }
  7. // 长方形
  8. interface Rectangle {
  9.     kind: "rectangle";
  10.     width: number; // 宽
  11.     height: number; // 高
  12. }
  14. // 圆
  15. interface Circle {
  16.     kind: "circle";
  17.     r: number; // 半径
  18. }
  20. type Shape = Square | Rectangle | Circle;
  21. // 计算面积: 利用两种类型共有的kind属性,创建不同的类型保护区块
  22. // function area(s: Shape): number {
  23. function area(s: Shape) {
  24.     switch (s.kind) {
  25.         case "square":
  26.             return s.side * s.side;
  27.         case "rectangle":
  28.             return s.height * s.width;
  29.         case "circle":
  30.             return Math.PI * s.r ** 2;
  31.         default:
  32.             // 在default中检查未被之前case捕捉到的类型是否为never类型;
  33.             // 如果s是never类型, 说明前面的所有分支都被覆盖了, 这个分支永远不会走到;
  34.             // 如果s不是never类型, 说明前面的分支有遗漏, 需要补上这个分支;
  35.             return ((e: never) => {
  36.                 throw new Error(e);
  37.             })(s);
  38.     }
  39. }
  41. console.log(area({ kind: "circle", r: 1 })); // 3.141592653589793