@ badrap/ 结果

TypeScript 结果类型从 鲁斯特的结果 财务报告和审定财务报表 哈斯克也一样 类型。 目标是:

• 小型平面平面: 混合和匹配 Rust's Result and Haskell's either type, 但修改后使体验 TypeScript-y (TypeScriptic? TypeScriptalicious?) 。 当然,这是相当主观的.
• 编码错误应丢出: 当 结果# 图 财务报告和审定财务报表 结果# 链 在一起有点像 答应吧 但不同之处在于 他们不隐含地将错误包裹在回调中.
• 体能学但安全: 利用TypeScript的类型推论,使常见案例简单,同时保持类型安全. 这也有助于在Visual Studio代码等方面获得良好的编辑体验.

安装

$ npm i @badrap/result

使用量

import { Result } from "@badrap/result";

API 密码

结果<T, E 扩展出错 = 出错> 是一个类型,它既可以包入一个由 successful 计算结果的值,也可以包入类型 T级,或类型错误 页:1 表示计算失败.

该类型实际上是两种类型的结合: 结果。 行 <T, E> 语句 包罗成功值 结果. rr<T, E> 将错误包起来.

结果.ok/结果.err

结果 返回一个新的 结果。 还好 覆盖给定的值,同时 结果. err 返回一个新的 结果。 错误 覆盖给定错误.

const res = Result.ok(1);
res.isOk; // true

const res = Result.err(new Error());
res.isOk; // false

const res = Result.err(); // functionally equal to Result.err(new Error())
res.isOk; // false

结果。 还好 拥有额外的财产 价值 包含被包裹的值。 同样, 结果。 错误 拥有财产 错误 包含被包裹的错误。 在向TypeScript的类型检查器断言这样做是安全的后,可以访问. 这个 无效 财务报告和审定财务报表 是奥克 属性(见下文)对此有用.

const res = Math.random() < 0.5 ? Result.ok(1) : Result.err(new Error("oh no"));

if (res.isErr) {
  // TypeScript now knows that res is a Result.Err, and we can access res.error
  res.error; // Error("oh no")
}

if (res.isOk) {
  // TypeScript now knows that res is a Result.Ok, and we can access res.value
  res.value; // 1
}

结果#isOk/结果#isErr

结果# isOk 财务报告和审定财务报表 结果# isErr 是互补的只读属性. 是奥克 实值 true 页:1 结果。 还好 财务报告和审定财务报表 false 页:1 结果。 错误。 。 。 .

const ok = Result.ok(1);
ok.isOk; // true

const err = Result.err(new Error());
err.isOk; // false

无效 反向为 是奥克数字 : false 页:1 结果。 还好 财务报告和审定财务报表 true 页:1 结果。 错误。 。 。 .

const ok = Result.ok(1);
ok.isErr; // false

const err = Result.err(new Error());
err.isErr; // true

结果# 撤销

返回包裹值 结果。 还好 并抛出包裹的错误 结果。 错误。 。 。 . 它可以被修改为提供函数来将值和出错映射到某个值.

const ok = Result.ok(1);
const err = Result.err(new Error("oh no"));

ok.unwrap(); // 1
err.unwrap(); // throws Error("oh no")

ok.unwrap((value) => value + 1); // 2
err.unwrap((value) => value + 2); // throws Error("oh no")

ok.unwrap(
  (value) => value + 1,
  (error) => 0,
); // 2
err.unwrap(
  (value) => value + 2,
  (error) => 0,
); // 0

作为小小的额外方便,调用的结果类型不必相同. 这里有个例子 科亚.js 处理器, 使用假想 验证 函数返回 a 结果数字 :

app.use(async ctx =>
  await validate(ctx.request.body).unwrap(
    async (value: any) => {
      ...
    },
    error => {
      ctx.status = 422;
      ctx.body = {
        message: "validation failed"
      };
    }
  )
);

结果# 图

返回一个新的 结果 已应用特定功能/功能的 到被包好的值和错误.

const ok = Result.ok(1);
const err = Result.err(new Error("oh no"));

ok.map((value) => value + 1).unwrap(); // 2
err.map((value) => value + 1).unwrap(); // throws Error("oh no")

ok.map(
  (value) => value + 1,
  (error) => new Error("mapped"),
).unwrap(); // 2
err
  .map(
    (value) => value + 1,
    (error) => new Error("mapped"),
  )
  .unwrap(); // throws Error("mapped")

结果# 链

const ok = Result.ok(1);
const err = Result.err(new Error("oh no"));

ok.chain((value) => Result.ok(value + 1)).unwrap(); // 2
err.chain((value) => Result.ok(value + 1)).unwrap(); // throws Error("oh no")

ok.chain(
  (value) => Result.ok(value + 1),
  (error) => Result.ok(0),
).unwrap(); // 2
err
  .chain(
    (value) => Result.ok(value + 1),
    (error) => Result.ok(0),
  )
  .unwrap(); // 0

结果。 所有

返回一个新的 结果 所包裹的值为 收集输入数组的包裹值.

Result.all([Result.ok(1), Result.ok("test")]).unwrap(); // [1, "test"]

如果输入结果中的任何结果包成一个错误,则该结果按正值返回.

Result.all([Result.ok(1), Result.err(new Error("oh no"))]).unwrap(); // throws Error("oh no")

非阵列对象也可以作为参数给出. 这样的话 包裹 输出值也是一个对象.

Result.all({
  x: Result.ok(1),
  y: Result.ok("test"),
}).unwrap(); // { x: 1, y: "test" }

许可证

这个图书馆根据麻省理工学院的许可证颁发执照. 见 自由主义。 。 。 .