@abecodes/promise-helper 中文文档教程

Question

promise-helper

promise-helper 是一个简单的工具带，旨在帮助完成使用 promises 的更复杂的任务。 它支持诸如按顺序处理承诺、睡眠序列、 并行执行或有限并行执行，超时承诺和可取消承诺。

它是根据 UNLICENSE & 发布的。 支持现代环境。

Installation

使用 npm：

# global
$ npm i -g @abecodes/promise-helper

# dependency
$ npm i -S @abecodes/promise-helper

# dev dependecy
$ npm i -D @abecodes/promise-helper

在 Node.js 中：

// Require the package.
const ph = require("@abecodes/promise-helper");

API

sequence

// Default
ph.sequence(taskArray: [() => Promise<any>], cb?: (err, result) => any) => Promise<any>

// Adding timeout between each task
ph.sequence.withSleep(taskArray: [() => Promise<any>], timeout: number,cb?: (err, result) => any) => Promise<any>

// Adding a random timeout inbetween a given range between each task
ph.sequence.withSleepRange(taskArray: [() => Promise<any>], minTime: number, maxTime: number, cb?: (err, result) => any) => Promise<any>

sequence 方法接受一个 HOF 数组，这些 HOF 返回一个承诺并按顺序运行它们。 如果 sequence.withSleep 或 sequence.withSleepRange 被调用，序列将在每个任务后休眠。

Sequence 可以用作 Promise 或与回调一起使用。 如果一项任务失败，则整个序列将失败。 如果出现错误，所有以前的结果都将是可访问的（如果不是假的）。

如果用作承诺，它们将作为结果属性传递到错误对象中。

如果与回调一起使用，它们将作为结果参数传递。

// Example
const p = ph.sequence.withSleep(
    [
        () =>
            new Promise((resolve, reject) => {
                setTimeout(() => {
                    resolve("Hello");
                }, 200);
            }),
        () =>
            new Promise((resolve, reject) => {
                setTimeout(() => {
                    resolve("World");
                }, 200);
            }),
    ],
    2000
);
p.then(res => console.log(res)).catch(err => console.log(err, err.result));

parallel

// Default
ph.parallel(taskArray: [() => Promise<any>], cb?: (err, result) => any) => Promise<any>

// Triggering limited execution
ph.parallel.limited(taskArray: [() => Promise<any>], limit: number) => void

parallel 方法接受一个 HOF 数组，这些 HOF 返回一个 promise 并并行运行它们。

如果 parallel.limited 被调用， 只有给定数量的任务会并行运行。

Parallel 可以用作 Promise 或与回调一起使用。 如果一项任务失败，则整个序列将失败。

Parallel.limited 返回 void，因此每个任务都必须在初始化期间自行处理。

// Example
ph.parallel.limited(
    [
        () =>
            new Promise((resolve, reject) => {
                setTimeout(() => {
                    resolve("Hello");
                }, 200);
            }).then(res => console.log(res)),
        () =>
            new Promise((resolve, reject) => {
                setTimeout(() => {
                    resolve("World");
                }, 200);
            }).then(res => console.log(res)),
        () =>
            new Promise((resolve, reject) => {
                setTimeout(() => {
                    reject(new Error("oO"));
                }, 200);
            }).catch(res => console.log(res)),
        () =>
            new Promise((resolve, reject) => {
                setTimeout(() => {
                    resolve("working limited");
                }, 200);
            }).then(res => console.log(res)),
    ],
    2
);

timeout

// Default (throws timeout)
ph.timeout((executor: (resolve: (value?: any) => void, reject: (reason?: any)) => void) => void, timeout: number, onTimeout?: () => any) => Promise<any>

// Instead of throwing an error, withNull will resolve with null on timeout
ph.timeout.withNull((executor: (resolve: (value?: any) => void, reject: (reason?: any)) => void) => void, timeout: number, onTimeout?: () => any) => Promise<any>

timeout 方法创建一个绑定到超时的承诺。

如果 promise 未能及时响应，则会抛出错误。 如果使用了 timeout.withNull，它将解析为 null 而不是抛出。

由于 promise 的工作方式，原始 promise 仍将执行，但如果操作提供中止函数，则可以使用 onTimeout 回调触发。

// Example
const p = ph.timeout(
    (resolve, reject) => {
        req = https.get("https://www.google.de", res => resolve(res));
        req.on("error", err => reject(err));
        req.on("abort", () => reject());
    },
    20,
    () => req.abort()
);
p.then(res => console.log(res)).catch(err => console.log(err));

cancelable

// Invocation
const p = ph.cancelable((executor: (resolve: (value?: any) => void, reject: (reason?: any)) => void) => void) => Promise<any>

// cancel (throws canceled)
p.cancel(onCancel?: () => void)

// cancelWithNull resolves with null
p.cancelWithNull(onCancel?: () => void)

cancelable 方法创建一个可以随意取消的承诺。

如果取消，它将引发错误。 如果使用了 cancelable.cancelWithNull，它将解析为 null 而不是抛出。

由于 promise 的工作方式，原始 promise 仍将执行，但如果操作提供中止函数，则可以使用 onCancel 回调触发。

// Example
let req;

const p = ph.cancelable((resolve, reject) => {
    req = https.get("https://www.google.de", res => resolve(res));
    req.on("error", err => reject(err));
    req.on("abort", () => reject());
});
p.then(res => console.log(res)).catch(err => console.log(err));

setTimeout(() => p.cancel(() => req.abort()), 20);

Greetings

愿您喜欢使用这款软件，就像我喜欢编写它一样。 保持无错误，度过美好的一天 <3