JS 可以对值进行加减运算
如果把 TS 的类型系统的当作一门语言，
TS 可以对类型进行各种运算吗？
如果有，那么 TS 类型系统有那些运算呢？
联合类型（union type）(也叫做并集)
栗子🌰
type A1 = number;
type B1 = string;
type C1 = A1 | B1;
const c1: C1 = 42;
上述代码用图表示即为：
type A2 = { name: string };
type B2 = { age: number };
type C2 = A2 | B2;
const c2: C2 = {
name: 'John',
age: 18,
}
如何使用？
const f1 = (a: number | string) => {
a.xxx?
// 这里能使用出 a 的那些方法？
// 即不能把 a 当作 number
// 也不能把 a 当作 string
// 那么，怎么使用 a 变量呢？
}
想办法把类型取分开来即可：
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 都无法区分
const a = (params: Date | Date[]) => {
if (typeof params === 'object') {
params // 此时类型仍然为 Date | Date[]
}
}
但是我们还能使用 instanceof
instanceof
这个方法主要返回对象的类
const a = (params: Date | Date[]) => {
if (params instanceof Date) {
params // 此时类型收窄为 Date
} else if (params instanceof Array) {
params // 此时类型收窄为 Array
}
}
instanceof 的局限性：不支持 TS 独有的类型
type Person = {
age: number;
}
type Animal = {
name: string;
}
const a = (params: Person | Animal) => {
if (params instanceof Person) { // TODO: 报错，Person 是一个类型，而不是类
// ...
}
}
那么如何解决呢？
in
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
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 类型，但是随之而来的缺点就是 麻烦！那么有没有更简单的方法呢？
可辨别联合
直接上代码
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 无交集
则称为可辨别联合
断言
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 包含了所有的类型，但是仅仅限于那个时候，在了解过类型收窄以后，就不能这么理解了。
怎么证明？用反证法：
正常来说一旦出现联合类型，那么这个时候你的类型就不能再使用了
const a = (params: number | string) => {
a // 此时这里只能调用 number 和 string 的共用方法，无法调用比如 split 这种字符串特有方法
}
但是如果是 any，则可以继续使用
const a = (params: any) => {
a.split() // 不会报错
a.toFixed() // 不会报错
}
这个时候我们再来看看官方文档
解释为这是一个特殊的类型，如果你不想让你的类型报错你可以使用这个类型
其实文档也没有说的很清楚，目前来看 TS 绝大部分规则对 any 不生效
const a = (params: any) => {
const newParams: never = params // TODO: 报错
}
那么什么类型等于所有类型(除 never/unknown/any/void)的联合呢？为什么？
答案就是 unknown
const a = (params: unknown) => {
if (typeof === 'number') {
params.toFixed() // 这里的类型是 number
} elseif (params instanceof Data) {
params // 这里的类型是 Date
}
}
也就是说 unknown 可以收窄为任意类型，那么反过来说就是 unknown 就是所有类型的联合，必须通过收窄后才能使用
