TypeScript 中 any、unknown、never 和 void

大家好，我是前端西瓜哥。今天来学习 TS 中几个比较特殊的类型：any、never、never、void。

any

any 表示 任意类型。

它是任意类型的父类，任意类型的值都可以赋予给 any 类型：

// 编译不会报错
let anything: any = '前端西瓜哥';

let flag: boolean = true;
anything = flag;

anything = { num: 2 };
1
2
3
4
5
6
7

它可以表示任何类型，并使用它们的语法，就像写没有类型的原生 JS 一样。

// 编译不会报错
const a: any = 6;

a();
a.key1 = true;
1
2
3
4
5

any 相当于抛弃了类型系统，会让代码变得不可预测和难以维护，需要程序员小心维护，一有不慎会造成运行时的错误，所以尽量少用。

但在引入一些没有提供类型的第三方纯 JS 库时，还是得将它们标为 any，这个确实没啥办法。

除非你自己给第三方库写类型声明，但太不现实，因为你不熟悉第三方库的 API，且可能有很复杂的类型推导要实现。

any 的存在是为了兼容无类型的 JS。TS 作为 JS 的超集，用 any 开后门是不得不做的事情。

unknown

unknown 可以认为是 类型更安全的 any。

和 any 一样，unknown 也是任何类型的子类型，所有类型都可以传给 unknown，包括 any。

// 编译不会报错
let a: unknown = '前端西瓜哥';

let b: any;
a = b;

a = { num: 2 };
1
2
3
4
5
6
7

说 unknown 更安全，是因为 unknown 是不能进行任何操作的。如果要使用，需要用 as 来进行显式的类型断言。

declare const user: known;

// 报错，unknown 不能被使用
user.toLowerCase();

// 开发者认为 user 是个字符串
// 使用 as 进行类型推断才能使用
(user as string).toLowerCase();
1
2
3
4
5
6
7
8

或者我们可以用类型收窄（Type Narrowing）；

declare const user: unknown;

if (typeof user === 'string') {
  user.toLowerCase();
}
1
2
3
4
5

对于一些可疑的没有类型的变量，如果你不希望它被不小心使用，此时就可以用 unknown。

总结就是：unknown 能看不能用，想用先类型断言。

never

never 表示一个 无法被观测的类型，被赋予了该类型的变量什么都不能做。

使用 never 的一些场景。

（1）一个无法走到 return 返回值的函数，比如一定会抛出错误或死循环：

// 这里的 never 表示无法执行到函数返回它的返回值
function foo(): never {
  throw new Error('something wrong!')
}
1
2
3
4

（2）TS 在判断条件下会做类型的收窄，当类型收缩到无类型可用，类型就变成了 never：

function getData(id: number | string) {
  if (typeof id === 'string') {
    // id 类型变成了 string
  } else if (typeof id === 'number') {
    // id 类型变成了 number
  } else {
    // id 类型变成了 never
  }
}
1
2
3
4
5
6
7
8
9

或者做了一种不可能为 true 的类型收窄：

if (typeof id === 'number' && typeof id === 'string') {
  // id 不可能同时是 number 和 string
  // 所以会变成 never
}
1
2
3
4

或无法求出交集的交叉类型：

// ImpossibleType 会得到 never
type ImpossibleType = string & number;
1
2

（3）类型编程中，在做模式匹配时，如果匹配失败，还是要返回一个类型的。为了表示失败，返回一个 never 表示返回的类型是无法被使用的。

比如 TS 内置的 Parameters 高级类型，会通过模式匹配提取函数的参数数组类型。如果无法匹配到参数，会返回 never：

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never
1

（4）类型编程中，将一些类型丢弃。never 在联合类型以及重映射的 key 中会被丢弃。

比如 TS 内置的 Exclude 高级类型，会将联合类型 T 中的不属于 U 的 key 丢弃掉。

type Exclude<T, U> = T extends U ? never : T

type T = Exclude<"a" | "b" | "c", "a">;
// T 的类型为 "b" | "c"
// 其实应该是 never | "b" | "c"，但 never 无意义，被丢掉了
1
2
3
4
5

void

void 用于表示一个 函数没有返回值。

function sayHi(): void {
  console.log('Hi!');
}
1
2
3

当然在实际 JS 运行时，还是会返回一个默认的 undefined 的。但 TS 给返回值设置为 void，语义更好些。

总结

any 是任意类型，具有所有类型的行为，可被执行，可访问属性，超脱于类型系统之外。

unknown 则是类型更安全的 any，同样可以将任何类型赋给它，但不能执行任何操作，必须用类型断言来显示说明类型才能去执行操作。

never 是无法观测的类型，比如不会执行完的函数的返回值，合并结果不存在的交叉类型。在类型编程中非常活跃，常用于丢弃一些子类型。

void 就比较简单，只是代表函数没有返回值，没有其他的场景了。

我是前端西瓜哥，欢迎关注我，学习更多前端知识。