JS 可以对值进行加减运算
如果把 TS 的类型系统的当作一门语言，
TS 可以对类型进行各种运算吗？
如果有，那么 TS 类型系统有那些运算呢？

联合类型（union type）(也叫做并集)

栗子🌰

1
2
3
4
type A1 = number;
type B1 = string;
type C1 = A1 | B1;
const c1: C1 = 42;

上述代码用图表示即为：

1
2
3
4
5
6
7
type A2 = { name: string };
type B2 = { age: number };
type C2 = A2 | B2;
const c2: C2 = {
  name: 'John',
  age: 18,
}

如何使用？

1
2
3
4
5
6
7
const f1 = (a: number | string) => {
  a.xxx?
  // 这里能使用出 a 的那些方法？
  // 即不能把 a 当作 number
  // 也不能把 a 当作 string
  // 那么，怎么使用 a 变量呢？
}

想办法把类型取分开来即可：

1
2
3
4
5
6
7
const f1 = (a: number | string) => {
  if (typeof a === 'number') {
    a.toFixed(2) // 这里可以调用 Number 的方法
  } else {
    a.split('') // 这里可以调用 String 的方法
  }
}

这样一来，即可保证使用的安全，这种行为也叫类型收窄。

用JS做类型收窄

typeof

js 的 typeof 有以下几种返回值：

  • string
  • number
  • bigint
  • boolean
  • symbol
  • undefined
  • object
  • function

我们发现 tpyeof 的有以下的局限性：数组对象、普通对象、日期对象、null 都无法区分

1
2
3
4
5
const a = (params: Date | Date[]) => {
  if (typeof params === 'object') {
    params // 此时类型仍然为 Date | Date[]
  }
}

但是我们还能使用 instanceof

instanceof

这个方法主要返回对象的类

1
2
3
4
5
6
7
const a = (params: Date | Date[]) => {
  if (params instanceof Date) {
    params // 此时类型收窄为 Date
  } else if (params instanceof Array) {
    params // 此时类型收窄为 Array
  }
}

instanceof 的局限性：不支持 TS 独有的类型

1
2
3
4
5
6
7
8
9
10
11
type Person = {
  age: number;
}
type Animal = {
  name: string;
}
const a = (params: Person | Animal) => {
  if (params instanceof Person) {  // TODO: 报错，Person 是一个类型，而不是类   
    // ...
  }
}

那么如何解决呢？

in

1
2
3
4
5
6
7
8
9
10
11
12
13
type Person = {
  age: number;
}
type Animal = {
  name: string;
}
const a = (params: Person | Animal) => {
  if ('name' in params) {  
    params // 这里的类型为 Animal
  } else if ('age' in params) {
    params // 这里的类型为 Person
  }
}

in 的局限性：只能区分部分对象，比如没有相同属性的对象、日期对象、函数

思考，怎么有这么多的局限性

因为我们一直在用 js 的逻辑来判断 ts 里面的逻辑，这是两门语言，根本无法做到一一对应

更多收窄，见这份文档

众所周知：js 的类型系统就是辣鸡，那么有没有取分类型的万全之法

类型谓词/类型判断

is

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
type Person = {
  age: number;
  sex: number;
}
type Animal = {
  name: string;
  legs: string[];
}

const a = (params: Perosn | Animal) => {
  if (isPerson(a)) {
    params // 这里的类型一定为 Person  
  }
}

function isPerson(x: Person | Animal /* 这里可以写 any */): x is Person {
  // 这里可以使用上面所有的类型判断技巧
  return 'age' in x && 'sex' in x // 必须返回 boolean
}
const isAnimal = (x: any): x is Animal => 'name' in x && 'legs' in x && a instanceof Array

有点是支持所有 TS 类型，但是随之而来的缺点就是 麻烦！那么有没有更简单的方法呢？

可辨别联合

直接上代码

1
2
3
4
5
6
7
8
9
10
type Person = { kind: 'person'; name: string; age: number; }
type Animal = { kind: 'animal'; name: string; }

const a = (params: Person | Animal) => {
  if (params.kind === 'person') {
    params // 这里的类型为 Person 
  } elseif (params.kind === 'animal') {
    params // 这里的类型为 Animal
  }
}
  • 优点：把复杂类型的收窄变成简单类型的对比
  • 局限性：1. 必须加上相同属性 kind； 2. kind 的类型必须是简单类型; 3. 各类型中的 kind 无交集

则称为可辨别联合

断言

1
2
3
4
5
6
7
8
9
type Person = {
  age: number;
}
type Animal = {
  name: string;
}
const a = (params: Person | Animal) => {
  (params as Person).age // 强制告诉 ts 此时类型为 Person
}

思考：any 是否等于所有类型(除 never/unknown/any/void)的联合？为什么？

答案是不是

之前在基础类型中介绍过，并画过图，any 包含了所有的类型，但是仅仅限于那个时候，在了解过类型收窄以后，就不能这么理解了。

怎么证明？用反证法：

正常来说一旦出现联合类型，那么这个时候你的类型就不能再使用了

1
2
3
const a = (params: number | string) => {
  a // 此时这里只能调用 number 和 string 的共用方法，无法调用比如 split 这种字符串特有方法
}

但是如果是 any，则可以继续使用

1
2
3
4
const a = (params: any) => {
  a.split() // 不会报错
  a.toFixed() // 不会报错
}

这个时候我们再来看看官方文档

解释为这是一个特殊的类型，如果你不想让你的类型报错你可以使用这个类型

其实文档也没有说的很清楚，目前来看 TS 绝大部分规则对 any 不生效

1
2
3
const a = (params: any) => {
  const newParams: never = params // TODO: 报错
}

那么什么类型等于所有类型(除 never/unknown/any/void)的联合呢？为什么？

答案就是 unknown

1
2
3
4
5
6
7
const a = (params: unknown) => {
  if (typeof === 'number') {
    params.toFixed() // 这里的类型是 number
  } elseif (params instanceof Data) {
    params // 这里的类型是 Date
  }
}

也就是说 unknown 可以收窄为任意类型，那么反过来说就是 unknown 就是所有类型的联合，必须通过收窄后才能使用