我的需求很简单。我想将对 sendEmail 的调用延迟 100 毫秒。电子邮件服务提供商允许每秒最多发送 10 封电子邮件。

但是请注意，虽然 .map 是同步的，但它会立即返回一个 Promise。

我试过 setTimeout 没有用，比如 setTimeout(() => resolve(x), 100) 和 setTimeout(() => {return new Promise....}, 100)。

想法？

const promises = userEmailArray.map((userEmail) => {
  return new Promise((resolve, reject) => {
      ....
      mailer.sendEmail(userEmail);
      return resolve();
    });
  });
});
...
Promise.all(promises).then(() => resolve()).catch(error => reject(error));

最佳答案

有很多不同的方法可以解决这个问题。我自己可能只使用递归链式 promise ，然后您可以根据上一次调用的完成情况更精确地使用计时器，您可以使用 promise 来调用它并处理错误传播。

我在这里假设您的 mailer.sendEmail() 遵循 node.js 回调调用约定，因此我们需要“ promise ”它。如果它已经返回一个 promise ，那么您可以直接使用它而不是我创建的 sendEmail() 函数。

无论如何，这里有很多不同的方法。

延迟后调用相同的函数(延迟递归)

// make promisified version - assumes it follows node.js async calling convention
let sendEmail = util.promisify(mailer.sendEmail);

function delay(t, data) {
    return new Promise(resolve => {
        setTimeout(resolve.bind(null, data), t);
    });
}

function sendAll(array) {
    let index = 0;
    function next() {
        if (index < array.length) {
            return sendEmail(array[index++]).then(function() {
                return delay(100).then(next);
            });
        }        
    }
    return Promise.resolve().then(next);
}

// usage
sendAll(userEmailArray).then(() => {
    // all done here
}).catch(err => {
    // process error here
});

使用 setInterval 控制节奏

您也可以只使用 setInterval 每 100 毫秒启动一个新请求，直到数组为空:

// promisify
let sendEmail = util.promisify(mailer.sendEmail);

function sendAll(array) {
    return new Promise((resolve, reject) => {
        let index = 0;
        let timer = setInterval(function() {
            if (index < array.length) {
                sendEmail(array[index++]).catch(() => {
                    clearInterval(timer);
                    reject();                        
                });
            } else {
                clearInterval(timer);
                resolve();
            }
        }, 100);
    })
}

使用 await 暂停循环

并且，您可以在 ES6 中使用 await 来“暂停”循环:

// make promisified version - assumes it follows node.js async calling convention
let sendEmail = util.promisify(mailer.sendEmail);

function delay(t, data) {
    return new Promise(resolve => {
        setTimeout(resolve.bind(null, data), t);
    });
}

// assume this is inside an async function    
for (let userEmail of userEmailArray) {
    await sendEmail(userEmail).then(delay.bind(null, 100));
}

将 .reduce() 与 Promise 结合使用以对数组进行顺序访问

如果您不想累积一组结果，而只是想排序，那么一种规范的方法是使用由 .reduce() 驱动的 promise 链:

// make promisified version - assumes it follows node.js async calling convention
let sendEmail = util.promisify(mailer.sendEmail);

function delay(t, data) {
    return new Promise(resolve => {
        setTimeout(resolve.bind(null, data), t);
    });
}

userEmailArray.reduce(function(p, userEmail) {
    return p.then(() => {
        return sendEmail(userEmail).then(delay.bind(null, 100));
    });
}, Promise.resolve()).then(() => {
    // all done here
}).catch(err => {
    // process error here
});

使用 Bluebird 功能进行并发控制和延迟

Bluebird promise library有几个有用的内置功能可以帮助您:

const Promise = require('Bluebird');
// make promisified version - assumes it follows node.js async calling convention
let sendEmail = Promise.promisify(mailer.sendEmail);

Promise.map(userEmailArray, userEmail => {
    return sendEmail(userEmail).delay(100);
}, {concurrency: 1}).then(() => {
    // all done here
}).catch(err => {
    // process error here
});

请注意使用 {concurrency: 1} 功能来控制同时进行的请求数和内置 .delay(100) promise 方法。

创建通用的序列助手

而且，创建一个小的辅助函数来对迭代之间有延迟的数组进行排序可能会很有用:

function delay(t, data) {
    return new Promise(resolve => {
        setTimeout(resolve, t, data);
    });
}

async function runSequence(array, delayT, fn) {
    let results = [];
    for (let item of array) {
        let data = await fn(item);
        results.push(data);
        await delay(delayT);
    }
    return results;
}

然后，您可以在需要时随时使用该助手:

// make promisified version - assumes it follows node.js async calling convention
let sendEmail = util.promisify(mailer.sendEmail);

runSequence(userEmailArray, 100, sendEmail).then(() => {
    // all done here
}).catch(err => {
    // process error here
});

关于javascript - 为返回 promise 数组的 Array.map 调用添加毫秒延迟，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47625693/