交叉类型与联合类型

交叉类型：取所有类型的并集

联合类型：声明的类型并不确定，可以为多个类型中的一个

  1. interface DogInterface {
  2.     run(): void
  3. }
  4. interface CatInterface {
  5.     jump(): void
  6. }
  7. let pet: DogInterface & CatInterface = {
  8.     run() {},
  9.     jump() {}
  10. }
  12. let aas: number | string = 'a'
  13. let bbs: 'a' | 'b' | 'c'
  14. let ccs: 1 | 2 | 3
  16. class Dogs implements DogInterface {
  17.     run() {}
  18.     eat() {}
  19. }
  20. class Cats implements CatInterface {
  21.     jump() {}
  22.     eat() {}
  23. } 
  24. enum Master { Boy, Girl }
  25. function getPet(master: Master) {
  26.     let pet = master === Master.Boy ? new Dogs() : new Cats()
  27.     pet.eat()
  28.     return pet
  29. }
  30. interface Square {
  31.     kind: "square";
  32.     size: number;
  33. }
  34. interface Rectangle {
  35.     kind: 'rectangle';
  36.     width: number;
  37.     height: number;
  38. }
  39. interface Circle {
  40.     kind: 'circle',
  41.     r: number
  42. }
  43. type Shape = Square | Rectangle | Circle
  44. function area(s: Shape) {
  45.     switch (s.kind) {
  46.         case "square":
  47.             return s.size * s.size
  48.         case "rectangle":
  49.             return s.height * s.width
  50.         case "circle":
  51.             return Math.PI *s.r ** 2
  52.         default: 
  53.             return ((e: never) => {throw new Error(e)})(s)
  54.     }
  55. }
  56. console.log(area({kind: 'circle', r: 1}))

索引类型

  1. let objone = {
  2.     a: 1,
  3.     b: 2,
  4.     c: 3
  5. }
  6. // function getValues(obj: any, keys: string[]) {
  7. //     return keys.map(key => obj[key])
  8. // }
  9. function getValues<T, K extends keyof T>(obj: T, keys: K[]): T[K][] {
  10.     return keys.map(key => obj[key])
  11. }  
  12. console.log(getValues(objone, ['a', 'b']))
  13. console.log(getValues(objone, ['e', 'f']))
  15. // keyof T 索引类型的查询操作符
  16. interface Obj {
  17.     a: number,
  18.     b: string
  19. }
  20. let key: keyof Obj
  22. // T[K]
  23. let value: Obj['a']
  25. // T extends U

映射类型

  1. interface Obj {
  2.     a: string;
  3.     b: number;
  4.     c: boolean;
  5. }
  6. // 所有接口属性只读
  7. type ReadonlyObj = Readonly<Obj> 
  9. // 所有接口属性可选
  10. type PartialObj = Partial<Obj>
  12. // 抽取绑定的子集
  13. type PickObj = Pick<Obj, 'a' | 'b'>
  15. // 以上三种映射类型，官方统称同态，只会作用于obj的属性，不会引入新的属性
  17. // 非同态的
  18. type RecordObj = Record<'x' | 'y', Obj>

条件类型

由条件表达式所决定的类型

  1. // T extends U ? X : Y
  2. type TypeName<T> =
  3.     T extends string ? 'string' :
  4.     T extends number ? 'number' :
  5.     T extends boolean ? 'boolean' :  
  6.     T extends undefined ? 'undefined' : 
  7.     T extends Function ? 'function' :
  8.     "object";
  10. type T1 = TypeName<string>
  11. type T2 = TypeName<string[]>
  13. // (A | B) extends U ? X : Y
  14. // (A extends U ? X : Y) | (B extends U ? X : Y)
  15. type T3 = TypeName<string | string[]>
  17. type Diff<T, U> = T extends U ? never : T
  18. type T4 = Diff<"a" | "b" | "c", "a" | "e">
  19. // Diff<"a", "a" | "e"> | Diff<"b", "a" | "e"> | Diff<"c", "a" | "e">
  20. // never | "b" | "c"
  21. // "b" | "c"
  23. type NotNull<T> = Diff<T, undefined | null>
  24. type T5 = NotNull<string | number | undefined | null>
  26. // Exclude<T, U>
  27. // NonNullable<T>
  28. // Extract<T, U>
  29. type T6 = Extract<"a" | "b" | "c", "a" | "e">
  31. // ReturnType<T>
  33. type T7 = ReturnType<() => string>