TypeScript中的底层和顶层类型-一一网

注: 本篇文章来自英文翻译
原文链接: Bottom and Top types in typescript

底层和顶层类型是一个数学概念上的类型理论的概念，存在于许多编程语言中。它也存在于TypeScript中，并且是一个经常被忽视的重要概念。

TypeSript有两个顶层类型，any和unknown，还有一个底层类型never。

顶层类型

当你看到一个关于顶层类型的描述时，你一般会看到如下信息:

顶层类型是所有其他类型的超类型。

一个类型实际上是一组所有可能的值，这些值可以被绑定到一个变量或参数。

在基本的面向对象编程中，我们知道一个子类型变量或函数参数可以绑定到一个超类型。

例如，在下面的walkies函数中，有一个名为dog的参数，类型为一个超类型(Dog)，因此可以绑定到子类型Pitbull和Alsation。

class Dog {}
class Pitbull extends Dog {}
class Alsation extends Dog {}

function walkies(dog: Dog){}

walkies(new Pitbull());
walkies(new Alsation());

复制代码

同理，顶层类型意味着，类型系统中的所有其他类型都是顶层类型的子类型，因此我们可以为顶层类型变量分配任何内容，例如：

let n: unknown = 5;
let x: any = { foo: 'bar' };
let s: unknown = "foobar";

复制代码

下面的函数topAny和topUnknown可以接受任何类型的参数。

function topAny(value: any) {}
function topUnknown(value: unknown) {}

topAny({ foo: 'bar' });
topUnknown(8);
topUnknown("8");

复制代码

臭名昭著的any类型

使用any类似于让程序走逃生出口，它基本上是在告诉tsc编译器不要插手，让程序在没有任何编译时类型检查的情况下运行。

const func = (dog: any) => {
   dog.bark();  // the compiler trusts you that bark exists on dog
}

复制代码

any类型的使用相当于是回到了JavaSript的弱类型，应尽量避免使用，特别是现在unknown类型已经被引入。

unknown类型

unknown类型在TypeScript 3中被引入，与any类型稍有不同，你可以把它看作是一个类型安全的any类型。

就像所有类型的变量都可以赋值给any类型的变量，所有类型的变量都可以赋值给unknown类型的变量。

unknown类型的目标是成为一个最不可能的类型。虽然任何内容都可以被赋值给一个unknown类型的变量，但我们需要做类型窄化或条件判断，然后才能正确的使用该变量。

类型窄化

类型窄化是TypeScript中一个至关重要的概念，但是人们对于个概念的理解还不够充分。

在下面的例子中，type guards是用来窄化函数的参数类型，如下面代码中的第10行和第14行, 函数参数会被类型窄化到更具体的Dog 或Pitbull类型。

interface Dog {
  bark: () => void;
}

interface Pitbull extends Dog {
  attack: () => void;
}

const isDog = (value: any): value is Dog => { // value is Dog 是一个type guard
  return value && !!value.bark;
};

const isPitbull = (value: any): value is Pitbull => {
  return value && value.attack;
};

const walkies = (value: unknown) => {
  if (isPitbull(value)) {
    value.bark();
    value.attack();
    return;
  }

  if (isDog(value)) {
    value.bark();
  }

  // if we used any instead of unknown then
  // the compiler would allow this
  // value.bark();
  // but with unknown we ge†
  // TypeError: Object is of type 'unknown'。
};

复制代码

直接使用unknown类型的变量会有很多的限制，但是可以通过type guards将变量类型窄化到更具体的类型，然后按具体类型的变量进行使用。如果直接使用any类型的变量，则编译器将不做任何检查，可以调用任何方法。

看了前面关于顶层类型的解释，再来回顾下关于顶层类型的定义:

顶层类型是所有其他类型的超类型。

const walkies = (value: unknown) => {

复制代码

与Dog是Pitbull的超类型类似,unknown是每种类型的超类型，因此unknown类型的变量可以接受任何类型的变量的赋值，但与any类型不同，unknown类型的变量不能调用具体的方法，而是要使用type guards来窄化类型至具体的类型，然后再操作。

随着unknown的引入，我们没什么理由再去使用any了，因为使用any基本上意味着直接忽视了类型系统。

底层类型never

never表示从未出现的类型。这在类型范畴学中被称为底层类型。

举例如下：

永远不会返回的函数
type guards返回false的情况

如下示例，当一个异常被抛出时的编译器提示:

// const neverWalkies: (dog: Dog) => never
const neverWalkies = (dog: Dog) => {
  throw new Error('No walkies now');
}

复制代码

该异常意味着该函数将永远不会返回值，因此返回类型为never。

该never或底层类型的变量没有值。你可能会认为null或undefined是底层类型，但变量和参数可以被绑定到null或undefined来作为值，而never类型的变量表示永远不会发生的值。

所以，never到底是干什么用的呢？

第一个用途就是我们刚刚讲的，用于从不返回的函数。

另一个非常重要的用途是做类型条件判断时修剪不需要的值。

看一下TypeScript中内置的Extract工具类的定义:

/**
 * Extract from T those types that are assignable to U
 */
type Extract<T, U> = T extends U ? T : never;

复制代码

我们可以使用Extract来创建一个更具体的Tamedog类型：

// type TameDog = {
//   bark: () => void;
//   walk: () => void;
// }
type TameDog = Pick<Dog, Extract<keyof Dog, 'bark' | 'walk' | 'meow'>>;

const doggy: TameDog = {
  bark() {
    console.log('woof woof');
  },

  walk() {
    console.log('good doggy');
  },
};

复制代码