TypeScript 中 any、unknown 与 never 类型的深度解析

TypeScript 提供了三种特殊的类型定义，分别是 any、unknown 和 never。

any 类型

基本含义

any 类型代表无限制，该类型的变量可以被赋予任意类型的值。

let name:any = "hiyooo"

name.first = "轻奢男装店" //不报错
name.address = ['店铺正在开启中，有意，可以添加微信：Hi_YOOO']
name()  //不报错 ，

一旦将变量类型设置为 any，TypeScript 就会关闭对该变量的类型检查。即便存在明显的类型错误，只要语法正确，编译器也不会报错。

鉴于此原因，应尽量避免使用 any 类型，否则便失去了使用 TypeScript 的意义。

需要注意的是，这并不意味着完全不能使用 来声明变量类型。

在实际开发中，any 类型主要适用于以下两种场景。

（1）出于特殊原因，需要关闭某些变量的类型检查时，可以将该变量的类型设为 any。

（2）为了适配旧的 JavaScript 项目，使代码能快速迁移到 TypeScript，可以将变量类型设为 any。对于一些年代久远的大型 JavaScript 项目，尤其是他人编写的代码，很难为每一行代码适配正确的类型。此时，若为那些类型复杂的变量加上 any，TypeScript 在编译时便不会报错。

总之，TypeScript 认为，只要开发者使用了 any 类型，就表示开发者希望自行处理这些代码，因此不对 any 类型施加任何限制，允许随意使用。

从集合论的角度来看，any 类型可以被视为所有其他类型的全集，包含了一切可能的类型。TypeScript 将这种类型称为“顶层类型”（top type），意为涵盖了所有下层类型。

类型推断问题

对于开发者未指定类型、TypeScript 必须自行推断类型的变量，如果无法推断出具体类型，TypeScript 会将该变量的类型认定为 any。

function add(x, y) {
  return x + y;
}

add(1, [1, 2, 3]); // 不报错

在上面的示例中，函数 add() 的参数变量 x 和 y 都没有足够的信息，TypeScript 无法推断出它们的类型，因此会认为这两个变量和函数返回值的类型均为 any。这导致后续不再对函数 add() 进行类型检查，可以随意使用。

这显然是非常糟糕的情况，因此对于类型不明确的变量，务必显式声明类型，防止被推断为 any。

TypeScript 提供了一个编译选项 noImplicitAny，开启该选项后，只要推断出 any 类型就会报错。

此时可以在 tsconfig.json 中配置：noImplicitAny

上述命令使用了 noImplicitAny 编译选项进行编译，此时上面的函数 add() 就会报错。

污染问题

any 类型除了关闭类型检查外，还有一个严重问题，即它会“污染”其他变量。由于它可以赋值给任何类型的变量（因为没有类型检查），这会导致其他变量出错。

        let x :any = "aa"
        let y :number =10;

        y = x;   //不会报错
        y += 10; //不会报错

        y.toFixed(1) //不会报错

在上面的示例中，变量 x 的类型是 any，实际值是一个字符串。变量 y 的类型是 number，表示这是一个数值变量，但它被赋值为 x，此时并不会报错。随后，变量 y 继续进行各种数值运算，TypeScript 也检查不出错误，问题就这样留到了运行时才暴露。

污染其他具有正确类型的变量，并将错误留到运行时，这是不宜使用 any 类型的另一个主要原因。

unknown 类型

基本含义

它与 any 含义相同，表示类型不确定，可能是任意类型。

为了解决 any 类型“污染”其他变量的问题，TypeScript 3.0 引入了 unknown 类型。它与 any 含义相同，表示类型不确定，可能是任意类型，但它的使用有一些限制，不像 any 那样自由，可以视为严格版的 any。

unknown 跟 any 的相似之处在于，所有类型的值都可以分配给 unknown 类型。

let name: unknown;

name = true; // 正确
name = 42; // 正确
name = "hiyooo"; // 正确

在上面的示例中，变量 x 的类型是 unknown，可以赋值为各种类型的值。这与 any 的行为一致。

unknown 类型与 any 类型的不同之处在于，它不能直接使用。主要有以下几个限制。

1). unknown 类型的变量，不能直接赋值给其他类型的变量（除了 any 类型和 unknown 类型）。

2). 不能直接调用 unknown 类型变量的方法和属性。

3). unknown 类型变量能够进行的运算是有限的，只能进行比较运算（运算符 ==、===、!=、!==、||、&&、?）、取反运算（运算符 !）、typeof 运算符和 instanceof 运算符这几种，其他运算都会报错。

1）.
let name:unknown;

let first_name:string = name;// error 不能将类型“unknown”分配给类型“string”
let age:number  = name; // error 不能将类型“unknown”分配给类型“number”

// 这就避免了污染问题，从而克服了any类型的一大缺点。

2）.

let persion：unknown = {name:"hiyooo"}

persion.name;//error 这里会报错。 “person”的类型为“未知”

3).
let hiyooo: unknown = 1;

hiyooo + 1; // 报错 “hiyooo”的类型为“未知”。
hiyooo === 1; // 正确

那么，如何才能使用 unknown 类型变量呢？

答案是只有经过“类型缩小”，unknown 类型变量才可以使用。所谓“类型缩小”，就是缩小 unknown 变量的类型范围，确保不会出错。

let hiyooo: unknown = 1;

if (typeof hiyooo === "number") {
  let r = hiyooo + 10; // 正确
}

这样设计的目的是，只有明确 unknown 变量的实际类型，才允许使用它，防止像 any 那样可以随意乱用，“污染”其他变量。类型缩小以后再使用，就不会报错。

总之，unknown 可以看作是更安全的 any。一般来说，凡是需要设为 any 类型的地方，通常都应该优先考虑设为 unknown 类型。

在集合论上，unknown 也可以视为所有其他类型（除了 any）的全集，所以它和 any 一样，也属于 TypeScript 的顶层类型。

never 类型

基本含义

类型为空，不包含任何值。

目的

为了保持与集合论的对应关系，以及类型运算的完整性，TypeScript 还引入了“空类型”的概念，即该类型为空，不包含任何值。

由于不存在任何属于“空类型”的值，所以该类型被称为 never，即不可能有这样的值。

let hiyooo:never;

变量 hiyooo 的类型是 never，就不可能赋给它任何值，否则都会报错。

never 类型的使用场景，主要是在一些类型运算之中，保证类型运算的完整性。

如果一个变量可能有多种类型（即联合类型），通常需要使用分支处理每一种类型。这时，处理所有可能的类型之后，剩余的情况就属于 never 类型。

function fn(x: string | number) {
  if (typeof x === "string") {
    // ...
  } else if (typeof x === "number") {
    // ...
  } else {
    x; // never 类型
  }
}

never 类型的一个重要特点是，可以赋值给任意其他类型。

function f(): never {
  throw new Error("Error");
}

let v1: number = f(); // 不报错
let v2: string = f(); // 不报错
let v3: boolean = f(); // 不报错

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持本站。