1. never 类型

目标：能够知道 TS 中 never 类型的含义

知识点：

  1. never 类型：表示永不存在的值的类型。 例如，never 类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型

  2. never 类型：处理 TS 类型系统的最底层

  • 可以将 never 类型的数据，赋值给任意其他的类型
  • 无法将任何类型（除了 never 类型自己）来分配给 never 类型 ```typescript // 返回 never 的函数必须存在无法达到的终点 function error(message: string): never { throw new Error(message) }

// 返回 never 的函数必须存在无法达到的终点 function infiniteLoop(): never { while (true) {} }

// 返回 never 的函数必须存在无法达到的终点 const num = 123 if (num !== 123) { let n = num // n => never }

  4. <a name="e6JY6"></a>
  5. ## 2. unknown 类型
  6. > 目标：能够知道 TS 中的 unknown 类型
  9. **知识点：**
  11. 1. unknown 类型是类型安全的 any
  12. 1. 可以把任何类型的值赋值给 unknown 类型的变量（可以接口任意类型的数据）
  13. 1. 在使用 unknown 类型前，必须先将其设置为一个具体的类型，否则，无法对其进行任何操作
  15. 对比 any 和 unknown 类型：
  17. 1. 对于 any 类型来说，TS 不会对其进行类型检查
  18. ```typescript
  19. // 可以进行任意操作，没有安全可言
  20. let value: any
  21. value = true
  22. value = 1
  23. value.length
  1. unknown 类型 ```typescript let value: unknown value = ‘abc’

// 先转化为具体类型再使用 (value as string).length

// 先判断是 string 类型，再使用 if (typeof value === ‘string’) { value.length }

  3. <a name="OkTqf"></a>
  4. ## 3. never 类型和 unknown 类型
  5. > 目标：了解 never 类型 和 unknown 类型的区别
  8. **知识点：**
  10. 1. never 处理 TS 类型系统的最底层
  11. - 无法将任意类型的数据赋值给 never 类型
  12. - 可以将 never 类型赋值给任意其他类型
  13. - 理解：never 表示啥也不是，所以，无法给 never 设置任何内容
  14. - 理解：never 处于最底层，相当于任何类型的子类型，所以，可以赋值给其他任何类型
  15.    - 比如，'a' 字面量就是 string 的子类型 let s: string = 'a'
  17. 2. unknown 处于 TS 类型系统的最顶层
  18. - 可以将任意类型的数据赋值给 unknown 类型
  19. - 无法将 unknown 类型赋值给任意其他类型
  20. - 简单来说：unknown 类型可以接受任意类型，但是无法赋值给其他类型
  21. - 理解：unknown 表示不确定，不确定就可以表示任意类型，既然可以是任意类型，所以可接受任意类型数据
  22. - 理解：unknown 表示不确定，不确定就可以表示任意类型，既然可以是任意类型，所以就无法赋值给一个特点的类型
  23. ```typescript
  24. // 头部                                    底部
  25. unknown -> ... -> ...-> never
  27. unknown 可以按照 “万物皆对象” 的方式来理解：“万物皆 unknown”
  1. let u: unknown
  3. // 可以将任意类型的数据赋值给 unknown 类型
  4. u = 1
  5. u = 'a'
  7. // 错误演示：
  8. // let a: number = u

4. as const 常量断言

目标：能够理解TS中的常量断言 as const

知识点：

  1. as const 文档
  2. as const 也是一种类型断言，主要用于字面量类型，来得到字面量类型而不是其扩大后的类型，规则如下：
  • 简单类型的字面量，类型变为字面量本身，比如：不会再将字符串值 “hello” 推断为 string 类型
  • 对象字面量的属性变为 readonly
  • 数组字面量变为 readonly 元组 ```typescript // x 的类型是： string let x = ‘hello’

// 使用 const 断言后，x 的类型是： “hello” 字面量类型 let x = ‘hello’ as const

// y 的类型是： { readonly text: “hello” } let y = { text: “hello” } as const

// z 的类型是： readonly [10, 20] let z = [10, 20] as const

  4. <a name="EqQLJ"></a>
  5. ## 5. 非空断言
  6. > 目标：能够掌握 TS 中的非空断言的使用
  9. **知识点：**
  11. 1. 如果我们明确的知道对象的属性在使用时一定不为空，那么可以使用 TS 中提供的：非空断言
  12. 1. 非空断言：!，从可能为空的类型中，去掉 null 和 undefined 类型
  13. ```typescript
  14. let x: null | undefined | number
  16. // t1 的类型为：null | undefined | number
  17. let t1 = x
  19. // t2 的类型为：number
  20. let t2 = x!

注意：
使用非空断言时，一定要确保该属性不为空值，否则，即使类型不报错，将来在代码运行时也会报错！

  1. let x: null | undefined | number = null
  3. // 错误演示：
  4. // 类型不会报错，但是，代码运行时报错！因为 x 的值为 null
  5. x!.toString()