交叉类型

• 特别适合对象混用的场景
• 取并集

interface DogInterface {
  run(): void
}

interface CatInterface {
  jump(): void
}

let pet: Dog & Cat = {
  run(),
  jump()
}

联合类型

• 可以使类型具有一定的不确定性，可以增加代码的灵活性
• 变量联合类型

let a = number | string = 'a'
let b = 'a' | 'b' | 'c'
let c = 1 | 2 | 3

• 对象联合类型

class Dog implements DogInterface {
  run(){}
  eat(){}
}

class Cat implements CatInterface {
  jump(){}
  eat(){}
}

enum Master { Boy, Girl }

function getPet(master: Master){
  let pet = master = Master.Boy ? new Dog() : new Cat()
  pet.eat()
  return pet
}

interface Square {
  kind: 'square';
  size: number;
}

interface Rectangle { 
  kind: 'rectangle';
  width: number;
  height: number;
}

interface Circle {
  kind: 'circle', 
  r: number
}

// 联合类型
type Shape = Square | Rectangle

function area(s:Shape){
  switch (s.kind){
    case "square":
      return s.size * s.size;
    case "rectangle":
      return s.height * s.width
    case "circle":
      return Math.PI * s.r ** 2  
    default:
      // 检查s是不是nerver类型 如果是 前面分支case齐全。 s不是nerver类型 有遗漏的case没写
      return ((e: nerver) => {throw new Error(e)})(s)    
  }
}

console.log(area({kind: 'circle', r: 1}))