交叉类型与联合类型 第三节

交叉类型

将多个类型合并为一个类型， 新类型具有所有类型的特性

名称上看 交叉类型是取两个类型的交集，但这里其实是取类型的并集

interface DogInterface{
    name: string,
    run(): void
}
interface CatInterface{
    age: number,
    jump(): void
}
// 交叉类型必须满足所有类型
let pet: DogInterface & CatInterface = {
    name: '',
    age: 1,
    jump: ()=>{},
    run: ()=>{},
}

联合类型

当声明的类型并不确定，可能是多个类型中的一个

名称上看 联合类型是两个类型的并集， 但这里是取类型的交集

// 字面量联合类型
// 有时候我们不仅要限制一个变量的类型 而且要限定到 某个具体的范围内
let a: number | string = ''
let b: 'a' | 'b' | 'c' = 'c'
let c: 1 | 2 | 3 = 2

// 继续以上面的接口类型为例
// 联合类型必须完全满足其中一个类型如： name run() |  age jump()
let pet: DogInterface | CatInterface = {
    name: '',
    run: ()=>{},
}
// 我们继续看下面的例子
interface DogInterface{
  run(): void
  eat(): void
}
interface CatInterface{
  jump(): void
  eat(): void
}
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();
    // 使用联合类型时 在类型不确定的情况下那么它只能取 类型的共有成员 eat
    pet.eat()
    // 类型保护
    if(pet instanceof Dog){
        pet.run()
    }else{
        pet.jump()
    }
    return pet;
}

// 联合类型 通常利用共有的属性来创建 类型保护区块

interface Dog {
    name: 'xiaogou',
    age: number
}
interface Cat{
    name: 'xiaomao',
    color: string
}
interface Pig{
    name: 'xiaozhu',
    hobby: string 
}
type Animal = Dog | Cat | Pig;
/* 当我们函数中并为校验 pig时返回 undefined 但没有报错
   通过两种方式进行解决：
    1、定义返回值类型   如：function animal():string{} 当返回值为undefined时提示错误
    2、定义never类型  当default 是never类型时，说明之前定义无效，需要检查错误
*/
function animal(params: Animal) {
    switch (params.name) {
        case 'xiaogou':
            return '我两岁了'
            break;
        case 'xiaomao':
            return '我是黄色的'
            break;
        default: 
            return ((e: never) => { throw new Error(e) })(params);     
    }
}
console.log(animal({ name: 'xiaozhu', hobby: '吃'}))