函数重载

  1. function greet(name: string):string;
  2. function greet(name: string[]): string;
  4. function greet(name:unknown):string {
  5.   if(typeof name === 'string'){
  6.     return `hello ${name}`
  7.   } else if (Array.isArray(name)){
  8.     return `hello ${name.join(',')}`
  9.   }
  10.   return 'unkown'
  11. }
  13. const a = greet('Tom')
  14. const b= greet(['Tom', 'Marry'])
  16. console.log(a)
  17. console.log(b)

索引类型和Record类型

它们两个很多情况下都是一样的，就是索引类型中的key的类型比较少，只能是number、string、symbol

索引类型

索引类型的key只能是number、string、symbol、或者是字面量类型

  2. type AType  = {
  3.     [prop: number|string|symbol|`$${string}Change`]:any
  4. }
  6. const a:AType ={
  7.     name: 'Tom',
  8.     10: 'age'
  9. }

不能使用其他的，例如字面量联合类型

  1. type Level ='error'|'warn'|'info'
  3. type BType = {
  4.     [prop:Level]: any
  5. }
  6. //error 索引签名参数类型不能为文本类型或泛型类型。请考虑改用映射的对象类型。ts(1337)

Record类型

Record类型的中的key的类型是string|number|symbol|T

  2. type PersonKey = 'name'|'age'|'sex'
  3. type Person =Record<PersonKey,any>

keyof

  1. type User = {
  2.     name: string;
  3.     age: number;
  4.     sex: boolean
  5. }
  6. type U1 = User["name"]
  7. // string
  8. type U2 = User["name"|"age"]
  9. // string|number
  10. type U3 = User[keyof User]
  11. // string | number | boolean
  13. function getProperty<T extends object, K extends keyof object>(obj, key) {
  14.     return obj[key]
  15. }

映射类型

  1. type User = {
  2.     name: string;
  3.     age: number;
  4.     sex: boolean
  5. }
  7. type MyPartial<T> = {
  8.     [P in keyof T]?:T[P] 
  9. }
  11. type UserPartial = MyPartial<User>;
  12. //等同于
  13. type UserPartial = {
  14.     name?: string;
  15.     age?: number;
  16.     sex?: boolean;
  17. }

key remapping

  1. type MappedTypeWithNewKeys<T> = {
  2.   [K in keyof T as NewKeyType]: T[K]
  3. }
  1. type User = {
  2.     name: string;
  3.     age: number;
  4.     sex: boolean
  5. }
  7. type Getters<T> = {
  8.     [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
  9. }
  11. type UserGetters = Getters<User>;
  12. //等同于下面
  13. type UserGetters = {
  14.     getName: () => string;
  15.     getAge: () => number;
  16.     getSex: () => boolean;
  17. }
  19. //方便的移除类型中的某些Key
  20. type RemoveSexField<T> = {
  21.     [K in keyof T as Exclude<K, 'sex'>]: T[K]
  22. }
  24. type UserRemoveSexField = RemoveSexField<User>;
  25. //等同于下面
  26. type UserRemoveSexField = {
  27.     name: string;
  28.     age: number;
  29. }
  30. //等同于下面
  31. type C = Omit<User, 'sex'>