详解TypeScript 2.0标记联合类型与never类型

利用判别式联合类型设计支付方案

设想我们需要为系统用户支持的以下支付渠道建立模型

• 现金支付
• PayPal 配合指定的电子邮箱
• 信用卡 包含特定的卡号及安全码

针对上述支付渠道，我们可以定义一个 TypeScript 接口

interface Cash {
  kind: "cash";
}

interface PayPal {
  kind: "paypal",
  email: string;
}

interface CreditCard {
  kind: "credit";
  cardNumber: string;
  securityCode: string;
}

请注意，除了必要字段外，每种类型都包含一个名为 kind 的属性，这被称为判别式属性。在此处，每种情况均为字符串字面量类型。

接下来定义 PaymentMethod 类型，它是前述三种类型的并集。如此声明 PaymentMethod 类型的变量时，其值必须属于这三种组成类型之一：

type PaymentMethod = Cash | PayPal | CreditCard;

既然类型定义完毕，我们来编写一个接收支付方法并返回可读描述的函数：

function describePaymentMethod(method: PaymentMethod) {
  switch (method.kind) {
    case "cash":
      // Here, method has type Cash
      return "Cash";

    case "paypal":
      // Here, method has type PayPal
      return `PayPal (${method.email})`;

    case "credit":
      // Here, method has type CreditCard
      return `Credit card (${method.cardNumber})`;
  }
}

首先，该函数的类型注解极少，method 参数仅包含一个。除此之外，函数主体几乎完全是 ES2015 代码。

在 switch 语句的每个 case 分支中，TypeScript 编译器会将联合类型缩小至其对应的成员类型。例如，当匹配到 "paypal" 时，method 参数的类型从 PaymentMethod 缩小为 PayPal。因此，我们可以直接访问 email 属性，无需添加类型断言。

本质上，编译器通过跟踪程序控制流来缩小判别式联合类型的范围。除了 switch 语句外，它还考虑条件判断、赋值以及返回语句的影响。

function describePaymentMethod(method: PaymentMethod) {
  if (method.kind === "cash") {
    // Here, method has type Cash
    return "Cash";
  }

  // Here, method has type PayPal | CreditCard

  if (method.kind === "paypal") {
    // Here, method has type PayPal
    return `PayPal (${method.email})`;
  }

  // Here, method has type CreditCard
  return `Credit card (${method.cardNumber})`;
}

控制流类型分析使得使用判别式联合类型变得非常顺畅。凭借最少的 TypeScript 语法开销，我们可以编写近乎纯 JavaScript 的代码，同时依然享受类型检查和代码补全带来的便利。

利用判别式联合类型构建 Redux 动作

判别式联合类型在 TypeScript 应用中结合 Redux 使用时能发挥巨大作用。我们编写一个示例，包含一个模型、两个动作以及 Todo 应用的 reducer。

以下是一个简化的 Todo 类型，表示单个待办事项。此处使用 readonly 修饰符以防止属性被修改。

interface Todo {
  readonly text: string;
  readonly done: boolean;
}

用户可以添加新的 todos 并切换现有 todos 的完成状态。根据这些需求，我们需要两个 Redux 动作，如下所示：

interface AddTodo {
  type: "ADD_TODO";
  text: string;
}

interface ToggleTodo {
  type: "TOGGLE_TODO";
  index: number
}

与前面的示例类似，现在可以将 Redux 动作构建为应用支持的所有动作的并集

type ReduxAction = AddTodo | ToggleTodo;

在本例中，type 属性充当判别式属性，并遵循 Redux 中常见的命名约定。现在添加一个与这两个 action 协同工作的 Reducer：

function todosReducer(
  state: ReadonlyArray<Todo> = [],
  action: ReduxAction
): ReadonlyArray<Todo> {
  switch (action.type) {
    case "ADD_TODO":
      // action has type AddTodo here
      return [...state, { text: action.text, done: false }];

    case "TOGGLE_TODO":
      // action has type ToggleTodo here
      return state.map((todo, index) => {
        if (index !== action.index) {
          return todo;
        }

        return {
          text: todo.text,
          done: !todo.done
        };
      });

    default:
      return state;
  }
}

同样，只有函数签名包含类型注释。代码的其余部分是纯 ES2015，而非 TypeScript 特有语法。

我们遵循与前面示例相同的逻辑。基于 Redux 动作的 type 属性，我们在不修改现有状态的前提下计算新状态。在 switch 语句的情况下，我们可以访问特定于每个动作类型的 text 和 index 属性，无需任何类型断言。

never 类型

TypeScript 2.0 引入了一个新的原始类型 never。never 类型表示永远不会出现的值的类型。具体而言，never 是永不返回函数的返回类型，也是变量在类型保护中永不为 true 的类型。

这些是 never 类型的确切特征，详述如下：

• never 是所有类型的子类型，并且可以赋值给所有类型。
• 没有类型是 never 的子类型或能赋值给 never（never 类型本身除外）。
• 在函数表达式或箭头函数没有返回类型注解时，如果函数没有 return 语句，或者仅有 never 类型表达式的 return 语句，并且如果函数是不可执行到终点的（例如通过控制流分析决定的），则推断函数的返回类型是 never。
• 在有明确 never 返回类型注解的函数中，所有 return 语句（如果有的话）必须有 never 类型的表达式并且函数的终点必须是不可执行的。

听起来有些抽象，接下来，通过几个例子来讲解 never 类型。

永不返回的函数

下面是一个永不返回的函数示例：

// Type () => never
const sing = function() {
  while (true) {
    console.log("我就是不返回值，怎么滴！");
    console.log("我就是不返回值，怎么滴！");
    console.log("我就是不返回值，怎么滴！");
    console.log("我就是不返回值，怎么滴！");
    console.log("我就是不返回值，怎么滴！");
    console.log("我就是不返回值，怎么滴！");
  }
}

该函数由一个不包含 break 或 return 语句的无限循环组成，因此无法跳出循环。因此，推断函数的返回类型是 never。

类似地，下面函数的返回类型被推断为 never

// Type (message: string) => never
const failwith = (message: string) => {
  throw new Error(message);
};

TypeScript 推断出 never 类型，因为该函数既没有返回类型注释，也没有可到达的端点 (由控制流分析决定)。

不可能存在该类型的变量

另一种情况是，never 类型被推断为从不为 true。在下面的示例中，我们检查 value 参数是否同时是字符串和数字，这是不可能的。

function impossibleTypeGuard(value: any) {
  if (
    typeof value === "string" &&
    typeof value === "number"
  ) {
    value; // Type never
  }
}

这个例子显然是过于刻意，来看一个更实际的用例。下面的示例展示了 TypeScript 的控制流分析缩小了类型守卫下变量的联合类型。直观地说，类型检查器知道，一旦我们检查了 value 是字符串，它就不能是数字，反之亦然

function controlFlowAnalysisWithNever(
  value: string | number
) {
  if (typeof value === "string") {
    value; // Type string
  } else if (typeof value === "number") {
    value; // Type number
  } else {
    value; // Type never
  }
}

注意，在最后一个 else 分支中，value 既不能是字符串，也不能是数字。在这种情况下，TypeScript 推断出 never 类型，因为我们将 value 参数注解为类型为 string | number，也就是说，除了 string 或 number，value 参数不可能有其他类型。

一旦控制流分析排除了 string 和 number 作为 value 类型的候选项，类型检查器就推断出 never 类型，这是唯一剩下的可能性。但是，我们就不能对 value 做任何有用的事情，因为它的类型是 never，所以我们的编辑器工具不会显示自动提示该值有哪些方法或者属性可用。

never 和 void 之间的区别

你可能会问，为什么 TypeScript 已经有一个 void 类型为何还需要 never 类型。虽然这两者看起来很相似，但它们是两个不同的概念：

没有显式返回值的函数将隐式返回 undefined。虽然我们通常会说这样的函数“不返回任何东西”，但它会返回。在这些情况下，我们通常忽略返回值。这样的函数在 TypeScript 中被推断为有一个 void 返回类型。

具有 never 返回类型的函数永不返回。它也不返回 undefined。该函数没有正常的完成，这意味着它会抛出一个错误，或者根本不会完成运行。

函数声明的类型推断

关于函数声明的返回类型推断有一个小问题。我们前面列出的几条 never 特征，你会发现下面这句话：

在函数表达式或箭头函数没有返回类型注解时，如果函数没有 return 语句，或者仅有 never 类型表达式的 return 语句，并且如果函数是不可执行到终点的（例如通过控制流分析决定的），则推断函数的返回类型是 never。

它提到了函数表达式和箭头函数，但没有提到函数声明。也就是说，为函数表达式推断的返回类型可能与为函数声明推断的返回类型不同：

// Return type: void
function failwith1(message: string) {
  throw new Error(message);
}

// Return type: never
const failwith2 = function(message: string) {
  throw new Error(message);
};

这种行为的原因是向后兼容性，如下所述。如果希望函数声明的返回类型 never，则可以对其进行显式注释：

function failwith1(message: string): never {
  throw new Error(message);
}

以上就是详解 TypeScript2.0 判别式联合类型的详细内容，更多关于 TS2.0 判别式联合类型的资料请关注本站其它相关文章！