typescript高级类型（day04）

高级类型

ts为了保证语言的灵活性，引入了一些特性，这些特性有助于我们面对复杂多变的开发场景。

交叉类型 & 联合类型

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

• 在 advanced.ts 中追加

  // 高级类型
  // 交叉类型 访问并集
  interface DogInterface {
      run(): void
  }
  interface CatInterface {
      jump(): void
  }
  let pet: DogInterface & CatInterface = {
      run() { },
      jump() { }
  }
  
  //联合类型 访问交集
  let aaa: number | string = 'a'
  
  //字面量联合类型
  let bbb: 'a' | 'b' | 'c'
  let ccc: 1 | 2 | 3
  
  class Dog1 implements DogInterface {
      run() { }
      eat() { }
  }
  
  class Cat1 implements CatInterface {
      jump() { }
      eat() { }
  }
  enum Master { Boy, Girl }
  function getPet(master: Master) {
      let pet = master === Master.Boy ? new Dog1() : new Cat1();
      pet.eat();
      //类型未确定的情况下只能访问所有类型的共有成员
      // pet.run();
      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 | Circle
  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:
              return ((e: never) => { throw new Error(e) })(s);
      }
  }
  console.log(area({ kind: 'circle', r: 1 }))
  

索引类型

• 在 advanced.ts 中追加

  //索引类型
  let obj = {
      a: 1,
      b: 2,
      c: 3
  }
  function getValues<T,K extends keyof T>(obj: T, keys: K[]):T[K][] {
      return keys.map(key => obj[key])
  }
  console.log(getValues(obj, ['a', 'b']))
  // console.log(getValues(obj, ['e', 'f']))
  
  // keyof T 类型T的所有公共属性字面量的联合类型
  interface Obj {
      a: number,
      b: string
  }
  let key: keyof Obj
  
  // 索引访问操作符
  // T[k] 对象T的属性K所代表的类型
  let value:Obj['a']
  
  // T extends U 范型变量可以通过继承某些类型或者某些属性
  

映射类型

通过映射类型可以从一个旧的类型生成一个新的类型
比如把一个类型中的所有属性变为只读

• 在 advanced.ts 中追加

  //映射类型
  interface Obj{
      a1: string,
      b1: string,
      c1: string
  }
  //同态
  type ReadonlyObj = Readonly<Obj>;
  type PartialObj = Partial<Obj>;
  type PickObj = Pick<Obj,'a'|'b'>;
  //非同态
  type RecordObj = Record<'x'|'y',Obj>;
  
  

条件类型

• 在 advanced.ts 中追加

  //条件类型
  // T extends U ? X : Y
  type TypeName<T> =
      T extends string ? "string" :
      T extends number ? "number" :
      T extends boolean ? "boolean" :
      T extends undefined ? "undefined" :
      T extends Function ? "function" :
      "object";
  
  type T1 = TypeName<string>
  type T2 = TypeName<string[]>
  
  // ( A | B ) extends U ? X : Y
  // (A extends U ? X : Y) | (B extends U ? X : Y)
  type T3 = TypeName<string | string[]>
  
  type Diff<T, U> = T extends U ? never : T
  type T4 = Diff<"a" | "b" | "c", "a" | "e">
  // Diff<"a" , "a" | "e"> | Diff<"b" , "a" | "e"> | Diff<"c" , "a" | "e">
  // never | "b" | "c"
  // "b" | "c"
  
  type NotNull<T> = Diff<T, undefined | null>
  type T5 = NotNull<string | number | undefined | null>
  
  //Exclude
  //NonNullable
  
  //Extract
  type T6 = Extract<"a" | "b" | "c", "a" | "e">
  
  //ReturnType
  type T7 = ReturnType<() => string>