调用数组函数，按顺序返回 Promise，无需外部依赖

Question

不使用任何额外的库（async、bluebird 等） 我正在尝试实现一个函数，该函数返回一个基于返回 Promise 的函数数组的 Promise 解析（或拒绝）输入参数...Promise.all(iterable) 与我尝试完成的功能非常相似，但 Promise.all 的 iterable 参数中的承诺不按顺序执行。

我可以简单地将这些函数链接在一起，但是如果functionList是一个未知长度的列表...

我已经尝试在概念上展示我想要在下面完成的工作：

function foo() {
  return new Promise((resolve, reject) => {
    setTimeout( () => {
        return resolve();
       }, 200);
  })
}

function bar() {
  return new Promise((resolve, reject) => {
    setTimeout( () => {
        return resolve();
       }, 200);
  })
}

function baz() {
  return new Promise((resolve, reject) => {
    setTimeout( () => {
        return reject();
       }, 100);
  })
}

const functionList = [foo, bar, baz];

function promiseSeries(functionList){
    const results = [];
    return new Promise((resolve, reject) => {
      promiseList.map((promise, i) => {
        return new Promise((_resolve, _reject) => {
          promise()
            .then((result) => {
              results.push(result);
              if (i === promiseList.length - 1) {
                return resolve(results);
              }
               else return _resolve();
            })
            .catch(error => error)
        })
      })
    })
  }

显然在 functionList 上运行 Promise.all 我们会看到 baz（即使它的位置是 functionList[2] 首先解析）

Resolve promises one after another (i.e. in sequence)? 或 Running promises in small concurrent batches (no more than X at a time) 均未提供此问题的答案。我不想导入一个库来处理这个单一的实用函数，而且我只是好奇这个函数会是什么样子。

Answer 1

promises.reduce((previous, promise) => {
  if (previous) {
    return previous.then(() => promise);
  }
  return promise;
}, null)

Answer 2

最简单的方法是链接它们，从一个 null 承诺开始：

const promises = [foo, bar, baz];
let result = Promise.resolve();
promises.forEach(promise => result = result.then(() => promise));
return result;

正如 Ali 指出的，您可以使用归约来代替，但您需要在 then 调用中使用函数：

return promises.reduce(
    (result, promise) => result.then(() => promise),
    Promise.resolve()
);

如果你知道 promises 不为空，你可以省略初始值。

但是，如果您真的想按顺序执行操作，您通常需要处理一组返回 Promise 的函数。例如：

return ids.map(id => () => processId(id))
.reduce((p, fn) => p.then(fn), Promise.resolve());

Answer 3

这并不比以下更复杂：

funcs.reduce((prev, cur) => prev.then(cur), Promise.resolve())

递归版本，返回解析值的数组：

function recurse([first, ...last], init) {
  if (!first) return Promise.resolve([]);
  return first(init)
    .then(value => 
      recurse(last, value)
        .then(values => [value, ...values])
    );
}

// Testing function to return a function which
// returns a promise which increments its value.
const x = v => y => Promise.resolve(v + y);
    
recurse([x(1), x(2)], 0).then(console.log);

Answer 4

在没有任何额外库的情况下实现此目的的一种简洁明了的方法是使用递归。一个例子：

const p1 = () => Promise.resolve(10);
const p2 = () => Promise.resolve(20);
const p3 = () => Promise.resolve(30);

const promiseList = [p1, p2, p3];

const sequencePromises = (promises) => {
  const sequence = (promises, results) => {
    if (promises.length > 0) {
      return promises[0]()
        .then(res => sequence(promises.splice(1, promises.length), results.concat(res)))
        .catch(err => Promise.reject(err));
    } else {
      return Promise.resolve(results);
    }
  }
  return sequence(promises, []);
}

sequencePromises(promiseList)
   .then(res => console.log(res))
   .catch(err => console.log("ERROR"));