TS类型: never 和 unknown

一、never类型

never 类型：永远不会出现的值的类型（或永远不会发生的类型）

// 1
let fn = () => {
  // 手动通过 throw 抛出一个异常（错误）
  throw new Error('err...')
}
let n = fn() // n => never

// 2
let fn = () => {
  while (true) {}
}
let n = fn() // n => never

// 3
const num = 123
if (num !== 123) {
  let n = num // n => never
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

二、unknown类型

• unknown 类型：类型安全的 any
• 可以把任何类型的值赋值给 unknown 类型的变量（可以接收任意类型的数据）
• 在使用 unknown 类型前，必须先将其设置为一个具体的类型，否则，无法对其进行任何操作

2.1 对比 any 和 unknown 类型：

1. 对于 any 类型来说，TS 不会对其进行类型检查

// 可以进行任意操作，没有安全可言
let value: any
value = true
value = 1
value.length
1
2
3
4
5

2. unknown 类型

let value: unknown
value = 'abc'

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

// 先判断是 string 类型，再使用
if (typeof value === 'string') {
  // value => string
  value.length
}
1
2
3
4
5
6
7
8
9
10
11

三、never和unknown对比

never 和 unknown 类型，分别处在 TS 类型的两端

注意：
any 不属于 TS 类型系统重，所以，只要使用了 any 类型，就相当于逃离了 TS 类型系统的约束了，也就没有类型安全可言了

// 头部									底部
unknown -> ... -> ...-> never
1
2

3.1 unknown 处于 TS 类型系统的最顶层

• 理解：unknown 处于最顶层，相当于任意类型的父类型（任意类型的父亲），所以，可以将任意类型赋值给它（其他任意类型都是它儿子）
• 特点：unknown 类型可以接受任意类型，但是无法赋值给其他类型

3.2 never 处理 TS 类型系统的最底层

• 理解：never 处于最底层，相当于任意类型的子类型（任意类型的儿子），所以，可以赋值给其他任意类型（其他任意类型都是它父亲）
• 特点：never 类型可以赋值给任意类型，但是无法给 never 赋值其他类型

// 父级类型 = 子级类型

// unknown 是最顶级类型，是所有其他类型的“父亲”【出现在等号（=）左侧】
let u: unknown
u = 1
u = 'a'
u = [1, 3, 5]
// 错误：
// let a: number = u

// ---

// never 是最底层类型，是所有其他类型的“儿子”【出现在等号（=）右侧】
let fn = () => {
  throw new Error('err...')
}
let n: never = fn() // n => never
let a: number = 1
a = n
// 错误：
n = a

// ---
let s1: 'abc' = 'abc'
let s2: string

s2 = s1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27