核心概念：函数式错误处理与 Monad
函数式错误处理的基本思想
函数式错误处理强调将错误视为数据来处理，而不是通过抛出异常来打断程序流程。通过这种方式，错误与业务逻辑可以像普通值一样经过组合、映射和变换，保持代码的可预测性。
在这种模式下，Monad 提供一个统一的上下文来封装值及潜在的错误，使错误能够在链式调用中平滑地传递与转化，而不破坏纯函数的性质。
常见的 Monad 类型包括 Maybe/Option、Either、以及 Try 等，它们在不同场景下对错误进行建模，用来实现可组合的错误处理。
Monad 的作用与常见类型
通过 map 和 flatMap/chain，可以在保持纯函数的前提下实现错误的传播与变换，从而避免异常打断控制流。
Maybe 将值分为“存在”与“不存在”两种状态，适合处理可能为 null 或 undefined 的情景；Either 将错误与成功的结果分开，提供一个明确的 Left/Right 结构来承载信息。
// 简单的 Maybe 示例（概要）
// 仅用于演示，不包含完整的边界处理
class Maybe {constructor(value) { this.value = value; }static of(value) { return new Maybe(value); }isNothing() { return this.value === null || this.value === undefined; }map(fn) { return this.isNothing() ? Maybe.of(null) : Maybe.of(fn(this.value)); }chain(fn) { return this.isNothing() ? Maybe.of(null) : fn(this.value); }
}
在 JavaScript 中实现 Monad 的路线
实现 Maybe 与 Either 的核心接口
要在 JavaScript 项目中实现函数式错误处理，首先需要定义一个可组合的上下文。Maybe 提供了一个容错包装，Either 则通过 Left 与 Right 来明确错误与成功的分支。
通过这两个类型，可以在 map、chain（又名 flatMap）等操作中进行错误的逐步积累和传播。
// 简化的 Either 实现（Left/Right）示例
class Left {constructor(value) { this.value = value; this.isLeft = true; this.isRight = false; }map(_) { return this; }chain(_) { return this; }fold(onLeft, _onRight) { return onLeft(this.value); }
}
class Right {constructor(value) { this.value = value; this.isLeft = false; this.isRight = true; }map(fn) { return new Right(fn(this.value)); }chain(fn) { return fn(this.value); }fold(_onLeft, onRight) { return onRight(this.value); }
}
把错误封装为可组合的单元
通过 Left 与 Right 的包装，错误信息可以作为数据在链条中传递，而不是直接抛出。这样就实现了错误的可组合化，便于调试和测试。
为了提升可用性，下面提供一个简单的 Left/Right 的工厂风格用法示例，便于在后续的映射/链接中继续处理。
class Left {constructor(value) { this.value = value; this.isLeft = true; this.isRight = false; }map(_) { return this; }chain(_) { return this; }
}
class Right {constructor(value) { this.value = value; this.isLeft = false; this.isRight = true; }map(fn) { return new Right(fn(this.value)); }chain(fn) { return fn(this.value); }
}
实战要点：从回调到 Monad 的迁移
从回调到 Either：错误传递的统一入口
在传统的回调模式中，错误往往通过回调参数向上传递。将错误改造为 Either 的 Left/Right，可以实现一个统一的入口点，避免混乱的错误分支分散在各处。
你可以定义一个简单的流程：将输入转换为 Left（错误）或 Right（成功），再通过 map、chain 等方法进一步处理。
// 例：将字符串解析为数字，失败返回 Left
function parseIntSafe(s) {const n = Number(s);return Number.isNaN(n) ? new Left('Invalid number') : new Right(n);
}// 使用示例
parseIntSafe('42').map(n => n * 2).fold(err => console.error('Error:', err),val => console.log('Value:', val));
函数组合与错误传播的模式
通过 map 与 chain，错误可以沿着链式调用继续传播，保持业务逻辑的清晰度。Left 的分支会把后续的映射保持不变，而 Right 则推进计算。
这使得你可以在第一处错误被捕获后，快速回退或渲染错误信息，同时避免了深层的嵌套回调。
const result = parseIntSafe('abc').map(n => n * 2) // 由于是 Left，map 不会执行.fold(err => `Error: ${err}`,v => `Result: ${v}`);
console.log(result);
异步场景中的 Monad：Task/Either 的组合策略
处理异步失败的模式
在异步场景中，Promise 与错误建模的结合尤为重要。将 Either 与 Task（或自定义的异步 Monad，如 TaskEither）结合，可以在异步流程中实现可预测的错误处理与组合。
一个简化的思路是：TaskEither 保存一个 Promise 包裹的 Either；通过 map、chain，你可以在异步完成后继续进行错误传递与变换。
// 极简的 Async Either（TaskEither 风格）示例（伪实现）
// 假设 Right(value) 表示成功， Left(error) 表示失败
class TaskEither {constructor(p) { this.p = p; }static of(x) { return new TaskEither(Promise.resolve(new Right(x))); }map(fn) {return new TaskEither(this.p.then(e => e.isLeft ? e : new Right(fn(e.value))));}chain(fn) {return new TaskEither(this.p.then(e => e.isLeft ? e : fn(e.value).p));}fold(onLeft, onRight) {return this.p.then(e => e.isLeft ? onLeft(e.value) : onRight(e.value));}
}
class Left { constructor(v){ this.value = v; this.isLeft = true; this.isRight = false; } }
class Right { constructor(v){ this.value = v; this.isLeft = false; this.isRight = true; } }// 使用示例（伪数据）
const ta = new TaskEither(Promise.resolve(new Right('data fetched')));
ta.map(d => d.toUpperCase()).fold(err => console.error('Async error:', err),v => console.log('Async success:', v));
