JS `Pattern Matching` (提案) `Discriminant Union` 与 `Exhaustiveness Checking`

各位听众，早上好！今天咱们来聊聊JavaScript里那些让代码更清晰、更安全的新玩意儿：模式匹配（Pattern Matching）、可辨识联合（Discriminant Union）和穷尽性检查（Exhaustiveness Checking）。

开场白：告别意大利面式代码

大家有没有经历过这样的噩梦：一大坨 if...else if...else 嵌套，逻辑混乱，改起来提心吊胆，生怕动了一处就牵一发而动全身？或者，一个函数接收各种各样的参数类型，内部用一堆 typeof 或者 instanceof 来判断，看着就头大？

这些问题，在其他语言里，比如 Rust、Haskell、Swift，早就有了优雅的解决方案。而现在，JavaScript也开始拥抱这些理念了。

第一部分：模式匹配（Pattern Matching）——“你瞅啥？瞅你像谁！”

模式匹配，简单来说，就是把一个值（被匹配的值，也叫“subject”）和多个模式（pattern）进行比较，如果匹配上了，就执行对应的代码。

想象一下，你站在人群里，别人瞅你一眼，然后说：“你长得像我二舅！” 这就是一种简单的模式匹配：别人把你（subject）和他们二舅（pattern）进行了比较。

JavaScript里的模式匹配，目前还没有官方实现，但已经有提案（虽然提案已经多年没更新了，但思想是值得学习的）。我们可以用一些库或者自己手写来实现类似的功能。

1.1 模式匹配的常见形式

• 字面量匹配（Literal Matching）： 匹配固定的值。

  function describeNumber(num) {
    switch (num) {
      case 0:
        return "零";
      case 1:
        return "一";
      case 2:
        return "二";
      default:
        return "很多";
    }
  }
  
  console.log(describeNumber(1)); // 输出: 一
  console.log(describeNumber(5)); // 输出: 很多

  这其实就是 switch...case 的基本用法，但我们很快会看到，模式匹配远不止于此。

• 对象解构匹配（Object Destructuring Matching）： 匹配对象的属性。

  function describePoint(point) {
    switch (true) { // 注意这里，需要匹配 true
      case point.x === 0 && point.y === 0:
        return "原点";
      case point.x > 0 && point.y > 0:
        return "第一象限";
      case point.x < 0 && point.y > 0:
        return "第二象限";
      default:
        return "其他地方";
    }
  }
  
  console.log(describePoint({ x: 1, y: 1 })); // 输出: 第一象限
  console.log(describePoint({ x: -1, y: 1 })); // 输出: 第二象限

  这种方式虽然能实现对象属性的匹配，但是看起来很笨重，而且容易出错。如果未来JavaScript有更强大的模式匹配语法，可以这样写（这只是个示例，不是现在的JavaScript语法）：

  // 假想的模式匹配语法
  function describePoint(point) {
    match (point) {
      case { x: 0, y: 0 }:
        return "原点";
      case { x > 0, y > 0 }:
        return "第一象限";
      case { x < 0, y > 0 }:
        return "第二象限";
      default:
        return "其他地方";
    }
  }

  这种语法更简洁，更易读。

• 数组解构匹配（Array Destructuring Matching）： 匹配数组的元素。

  function describeArray(arr) {
    switch (true) {
      case arr.length === 0:
        return "空数组";
      case arr.length === 1:
        return "只有一个元素的数组";
      case arr.length === 2:
        return "有两个元素的数组";
      default:
        return "有很多元素的数组";
    }
  }
  
  console.log(describeArray([])); // 输出: 空数组
  console.log(describeArray([1, 2])); // 输出: 有两个元素的数组

  和对象解构匹配类似，这种方式也很繁琐。理想的模式匹配语法应该是这样的：

  // 假想的模式匹配语法
  function describeArray(arr) {
    match (arr) {
      case []:
        return "空数组";
      case [a]:
        return "只有一个元素的数组";
      case [a, b]:
        return "有两个元素的数组";
      default:
        return "有很多元素的数组";
    }
  }

• 类型匹配（Type Matching）： 匹配值的类型。

  function describeValue(value) {
    switch (typeof value) {
      case "number":
        return "数字";
      case "string":
        return "字符串";
      case "boolean":
        return "布尔值";
      default:
        return "其他类型";
    }
  }
  
  console.log(describeValue(123)); // 输出: 数字
  console.log(describeValue("hello")); // 输出: 字符串

  这种方式依赖 typeof 操作符，但不够精确。比如，typeof null 返回 "object"，但我们可能需要更精确的判断。

1.2 一个更复杂的例子：用模式匹配处理 Redux actions

Redux 是一个流行的 JavaScript 状态管理库。在 Redux 中，我们通常需要处理各种各样的 actions。模式匹配可以使 action 处理逻辑更清晰。

// 定义 action 类型
const INCREMENT = "INCREMENT";
const DECREMENT = "DECREMENT";
const RESET = "RESET";

// 定义 action creators
const increment = () => ({ type: INCREMENT });
const decrement = () => ({ type: DECREMENT });
const reset = () => ({ type: RESET });

// reducer 函数
function reducer(state = 0, action) {
  switch (action.type) {
    case INCREMENT:
      return state + 1;
    case DECREMENT:
      return state - 1;
    case RESET:
      return 0;
    default:
      return state;
  }
}

这个例子中，我们用 switch...case 来处理不同的 action。如果 action 数量很多，switch...case 会变得很长，难以维护。

如果有了模式匹配，我们可以这样写（假想的语法）：

// reducer 函数 (假想的模式匹配语法)
function reducer(state = 0, action) {
  match (action) {
    case { type: INCREMENT }:
      return state + 1;
    case { type: DECREMENT }:
      return state - 1;
    case { type: RESET }:
      return 0;
    default:
      return state;
  }
}

虽然看起来和 switch...case 差不多，但模式匹配的优势在于：

• 更强的表达能力： 模式匹配可以匹配更复杂的结构，比如嵌套的对象和数组。
• 穷尽性检查： 编译器可以检查是否处理了所有可能的模式，避免遗漏。

第二部分：可辨识联合（Discriminant Union）——“我是谁？我从哪里来？我要到哪里去？”

可辨识联合，也叫标记联合（Tagged Union），是一种数据类型，它表示一个值可以是几种不同类型中的一种，并且每种类型都有一个共同的字段（辨识符，discriminant）来区分。

想象一下，你面前有一堆盒子，每个盒子上都贴着标签：“水果”、“蔬菜”、“肉类”。 你打开盒子之前，可以通过标签知道里面装的是什么。

在 JavaScript 中，我们可以用对象来模拟可辨识联合。

// 定义类型
const ResultType = {
  SUCCESS: "SUCCESS",
  FAILURE: "FAILURE",
};

// 定义联合类型
/**
 * @typedef {
 *   | { type: 'SUCCESS', data: any }
 *   | { type: 'FAILURE', error: Error }
 * } Result
 */

// 创建 Result 的函数
function createSuccessResult(data) {
  return { type: ResultType.SUCCESS, data };
}

function createFailureResult(error) {
  return { type: ResultType.FAILURE, error };
}

// 使用 Result
const successResult = createSuccessResult("Hello, world!");
const failureResult = createFailureResult(new Error("Something went wrong."));

console.log(successResult); // 输出: { type: "SUCCESS", data: "Hello, world!" }
console.log(failureResult); // 输出: { type: "FAILURE", error: Error: Something went wrong. }

在这个例子中，Result 是一个可辨识联合类型，它可以是 SUCCESS 或 FAILURE 两种类型。 type 字段是辨识符，用来区分不同的类型。

2.1 可辨识联合的优势

• 类型安全： 编译器可以根据辨识符来推断值的类型，避免类型错误。
• 代码可读性： 清晰地表达了值的可能类型，使代码更易于理解。
• 易于维护： 修改类型定义时，编译器会检查所有使用该类型的地方，确保代码的一致性。

2.2 一个更实际的例子：处理 API 请求

API 请求的结果通常有三种状态：加载中（Loading）、成功（Success）、失败（Failure）。 我们可以用可辨识联合来表示这三种状态。

// 定义类型
const ApiRequestStatus = {
  LOADING: "LOADING",
  SUCCESS: "SUCCESS",
  FAILURE: "FAILURE",
};

// 定义联合类型
/**
 * @typedef {
 *   | { type: 'LOADING' }
 *   | { type: 'SUCCESS', data: any }
 *   | { type: 'FAILURE', error: Error }
 * } ApiRequestResult
 */

// 创建 ApiRequestResult 的函数
function createLoadingResult() {
  return { type: ApiRequestStatus.LOADING };
}

function createSuccessResult(data) {
  return { type: ApiRequestStatus.SUCCESS, data };
}

function createFailureResult(error) {
  return { type: ApiRequestStatus.FAILURE, error };
}

// 模拟 API 请求
function fetchData() {
  return new Promise((resolve, reject) => {
    // 模拟加载中
    const loadingResult = createLoadingResult();
    console.log(loadingResult); // 输出: { type: "LOADING" }

    setTimeout(() => {
      // 模拟成功
      const data = { name: "John Doe", age: 30 };
      const successResult = createSuccessResult(data);
      console.log(successResult); // 输出: { type: "SUCCESS", data: { name: "John Doe", age: 30 } }
      resolve(successResult);

      // 模拟失败 (取消注释以测试失败情况)
      // const error = new Error("Failed to fetch data.");
      // const failureResult = createFailureResult(error);
      // console.log(failureResult); // 输出: { type: "FAILURE", error: Error: Failed to fetch data. }
      // reject(failureResult);
    }, 1000);
  });
}

// 使用 ApiRequestResult
fetchData()
  .then((result) => {
    if (result.type === ApiRequestStatus.SUCCESS) {
      console.log("Data:", result.data);
    }
  })
  .catch((result) => {
    if (result.type === ApiRequestStatus.FAILURE) {
      console.error("Error:", result.error);
    }
  });

在这个例子中，ApiRequestResult 是一个可辨识联合类型，它可以是 LOADING、SUCCESS 或 FAILURE 三种类型。 type 字段是辨识符。

第三部分：穷尽性检查（Exhaustiveness Checking）——“一个都不能少！”

穷尽性检查是指编译器检查是否处理了所有可能的情况。 在使用模式匹配和可辨识联合时，穷尽性检查可以帮助我们避免遗漏情况，从而减少错误。

想象一下，你是一位餐厅服务员，菜单上有三种菜：鱼香肉丝、宫保鸡丁、麻婆豆腐。 如果你只点了鱼香肉丝和宫保鸡丁，服务员会提醒你：“还有麻婆豆腐呢，您要不要来一份？” 这就是一种穷尽性检查。

在 JavaScript 中，由于缺乏静态类型系统，实现穷尽性检查比较困难。 但是，我们可以使用 TypeScript 或一些工具库来实现类似的功能。

3.1 使用 TypeScript 实现穷尽性检查

TypeScript 具有强大的类型系统，可以帮助我们实现穷尽性检查。

// 定义类型
enum ResultType {
  SUCCESS = "SUCCESS",
  FAILURE = "FAILURE",
}

// 定义联合类型
type Result =
  | { type: ResultType.SUCCESS; data: any }
  | { type: ResultType.FAILURE; error: Error };

// 处理 Result 的函数
function handleResult(result: Result) {
  switch (result.type) {
    case ResultType.SUCCESS:
      console.log("Success:", result.data);
      break;
    case ResultType.FAILURE:
      console.error("Failure:", result.error);
      break;
    default:
      // 如果没有处理所有情况，TypeScript 编译器会报错
      const _exhaustiveCheck: never = result;
      return _exhaustiveCheck;
  }
}

// 使用 Result
const successResult: Result = { type: ResultType.SUCCESS, data: "Hello, world!" };
const failureResult: Result = { type: ResultType.FAILURE, error: new Error("Something went wrong.") };

handleResult(successResult);
handleResult(failureResult);

// 如果我们添加一个新的 ResultType，但没有在 handleResult 中处理，TypeScript 编译器会报错。
// 例如：
// enum ResultType {
//   SUCCESS = "SUCCESS",
//   FAILURE = "FAILURE",
//   WARNING = "WARNING", // 添加一个新的类型
// }
//
// 此时，TypeScript 编译器会在 `const _exhaustiveCheck: never = result;` 这一行报错，
// 提示我们没有处理 ResultType.WARNING 的情况。

在这个例子中，我们使用了 TypeScript 的 never 类型来实现穷尽性检查。 如果 switch 语句没有处理所有可能的 ResultType，_exhaustiveCheck 变量的类型将不是 never，TypeScript 编译器会报错。

3.2 一个更复杂的例子：用 TypeScript 处理 Redux actions

// 定义 action 类型
enum ActionType {
  INCREMENT = "INCREMENT",
  DECREMENT = "DECREMENT",
  RESET = "RESET",
}

// 定义 action
type IncrementAction = { type: ActionType.INCREMENT };
type DecrementAction = { type: ActionType.DECREMENT };
type ResetAction = { type: ActionType.RESET };

// 定义联合类型
type Action = IncrementAction | DecrementAction | ResetAction;

// reducer 函数
function reducer(state: number = 0, action: Action): number {
  switch (action.type) {
    case ActionType.INCREMENT:
      return state + 1;
    case ActionType.DECREMENT:
      return state - 1;
    case ActionType.RESET:
      return 0;
    default:
      const _exhaustiveCheck: never = action;
      return _exhaustiveCheck;
  }
}

// 使用 reducer
const initialState = 0;
const incrementAction: Action = { type: ActionType.INCREMENT };
const newState = reducer(initialState, incrementAction);

console.log(newState); // 输出: 1

// 如果我们添加一个新的 ActionType，但没有在 reducer 中处理，TypeScript 编译器会报错。
// 例如：
// enum ActionType {
//   INCREMENT = "INCREMENT",
//   DECREMENT = "DECREMENT",
//   RESET = "RESET",
//   MULTIPLY = "MULTIPLY", // 添加一个新的类型
// }
//
// 此时，TypeScript 编译器会在 `const _exhaustiveCheck: never = action;` 这一行报错，
// 提示我们没有处理 ActionType.MULTIPLY 的情况。

总结：让代码更上一层楼

今天我们聊了模式匹配、可辨识联合和穷尽性检查。 这些技术可以帮助我们编写更清晰、更安全、更易于维护的 JavaScript 代码。

虽然 JavaScript 目前还没有官方的模式匹配语法，但我们可以使用一些库或者自己手写来实现类似的功能。 TypeScript 提供了强大的类型系统，可以帮助我们实现穷尽性检查。

希望今天的讲座能对大家有所启发。 谢谢大家！