类型断言

  • 给一些返回值是多种类型的变量或者函数，在确定返回值的情况下进行类型断言 ```typescript let obj: any = ‘str’

//方式一 let res: string = (obj).substr(0, 1) let res: string = (obj).toFixed(0, 1) // 如果值是 number

//方式二 let res: string = (obj as string).substr(0, 1)

  1. <a name="dUa7f"></a>
  2. ### symbol
  3. ```typescript
  4. // 声明一个symbol 值
  5. const s = Symbol()
  7. // 是独一无二的
  8. const s1 = Symbol()
  9. const s2 = Symbol()
  11. console.log(s1 === s2) // false
  13. const s1 = Symbol('name')
  14. const s2 = Symbol('name')
  16. console.log(s1 === s2) // false
  18. // 作为对象key
  19. const s3 = Symbol('name')
  20. const obj = {
  21.   [s3]: 'zxc'
  22. }
  24. obj[s3] = 'qwe' //只能通过[] 形式修改值，不能通过 obj.s3
  26. // 作为对象key 时，去获取
  27. for(const key in obj) //无法获取 symbol 作为key 的值
  29. Object.keys(obj)  //无法获取 symbol 作为key 的值
  31. Object.getOwnPropertyNames(obj) //无法获取 symbol 作为key 的值
  33. JSON.stringify(obj) //无法获取 symbol 作为key 的值
  35. Object.getOwnPropertySymbols(obj) // 只获取 symbol 作为key 的值
  37. Reflect.ownKeys(obj) // 可以获取到对象的所有key，包括 Symbol

Symbol.for

  • 在全局创建一个 Symbol 值 ```typescript const s1 = Symbol.for(‘zxc’) const s2 = Symbol.for(‘zxc’)

s1 === s2 // true

  1. <a name="gnMlJ"></a>
  2. #### Symbol.keyFor
  4. - 返回 Symbol.for() 创建的唯一标识
  5. ```typescript
  6. const s1 = Symbol.for('zxc')
  8. Symbol.keyFor(s1) // 返回的就是字符串 zxc

泛型

理解

  • 给某个值或者方法加上 类型变量，比如T，来指定返回的类型 ```typescript const getArray = (value: T, times: number = 5): T[] => { return new Array(times).fill(value) }

//当 value 是 string 时 getArray(‘zxc’, 3).map(item => item.length)

//当 value 是 number 时 getArray(10, 3).map(item => item.toFixed())

  2. - 多个泛型变量的使用
  3. ```typescript
  4. const getArray = <T, U>(arg1: T, arg2: U, times: number): [T, U][] => { 
  5.   //返回 [T, U][] T U 构成的元组
  6.   return new Array(times).fill([arg1, arg2])
  7. }
  9. //使用中针对不同元素
  10. getArray<number, string>(10, 'zxc', 3).forEach(item => {
  11.   item[0].toFixed()
  12.   item[1].length
  13. })

泛型定义函数类型

  1. let getArray: <T>(arg: T, times: number) => T[]
  3. //定义函数体
  4. getArray = (arg: string, times: number) = > {
  5.   return new Array(times).fill(arg)
  6. }
  8. //使用函数
  9. getArray('zxc', 3).map(item => item.length)

类型别名中使用泛型

  1. type GetArray: <T>(arg: T, times: number) => T[]
  3. //定义函数体
  4. let getArray: GetArray = (arg: string, times: number) = > {
  5.   return new Array(times).fill(arg)
  6. }
  8. //使用函数
  9. getArray('zxc', 3).map(item => item.length)

接口中使用泛型

  1. interface GetArray {
  2.   <T>(arg: T, times: number): T[]
  3. }
  5. //或者这样
  6. interface GetArray<T> {
  7.   (arg: T, times: number): T[]
  8. }

泛型约束

  • 通过 extends 关键字实现泛型约束
  • 约束 类型变量 T 的取值
  1. interface ValueWithLength {
  2.   length: number
  3. }
  5. const getArray = <T extends ValueWithLength>(arg: T, times: number): T[] => {
  6.   return new Array(times).fill(arg)
  7. }
  9. //正确
  10. getArray([1, 2], 3)
  11. getArray('zxc', 3)
  12. getArray({
  13.   length: 3
  14. }, 3)
  16. //错误， 因为不具备length属性
  17. getArray(10, 3)

在泛型约束中使用类型参数

  • 使用 keyof 关键字，获取类型变量上所有属性成员，并以数组的形式返回 ```typescript const getProps = (obj: T, propName: K) => { return obj[propName] }

const data = { name: ‘zxc’, age: 18 }

getProps(data, ‘name’) // 正确，因为有name属性 getProps(data, ‘address’) // 错误，因为没有address属性 ```