如果你真的想要一个promiseWhen()用于这个和其他目的的通用函数，那么一定要这样做，使用 Bergi 的简化。但是，由于 Promise 的工作方式，以这种方式传递回调通常是不必要的，并且会迫使您跳过复杂的小圈子。

据我所知，您正在尝试：

• 异步获取一组电子邮件地址的一系列用户详细信息（至少，这是唯一有意义的情况）。
• .then()通过递归构建链来实现。
• 处理返回结果时保持原来的顺序。

如此定义，问题实际上是Promise Anti-patterns 中“The Collection Kerfuffle”下讨论的问题，它提供了两个简单的解决方案：

• 并行异步调用使用 Array.prototype.map()
• 使用Array.prototype.reduce().

并行方法将（直接）给出您试图避免的问题 - 响应的顺序是不确定的。串行方法将构建所需的.then()链 - 扁平 - 无递归。

function fetchUserDetails(arr) {
    return arr.reduce(function(promise, email) {
        return promise.then(function() {
            return db.getUser(email).done(function(res) {
                logger.log(res);
            });
        });
    }, Promise.resolve());
}

调用如下：

//Compose here, by whatever means, an array of email addresses.
var arrayOfEmailAddys = [...];

fetchUserDetails(arrayOfEmailAddys).then(function() {
    console.log('all done');
});

如您所见，不需要丑陋的外部 varcount或其关联condition函数。限制（问题中的 10 个）完全由数组的长度决定arrayOfEmailAddys。

我认为它不能保证调用 logger.log(res); 的顺序。

事实上，确实如此。该语句在resolve调用之前执行。

有什么建议？

很多。最重要的是您使用create-promise-manually 反模式- 只做

promiseWhile(…, function() {
    return db.getUser(email)
             .then(function(res) { 
                 logger.log(res); 
                 count++;
             });
})…

其次，该while功能可以简化很多：

var promiseWhile = Promise.method(function(condition, action) {
    if (!condition()) return;
    return action().then(promiseWhile.bind(null, condition, action));
});

第三，我不会使用while循环（带有闭包变量），而是使用for循环：

var promiseFor = Promise.method(function(condition, action, value) {
    if (!condition(value)) return value;
    return action(value).then(promiseFor.bind(null, condition, action));
});

promiseFor(function(count) {
    return count < 10;
}, function(count) {
    return db.getUser(email)
             .then(function(res) { 
                 logger.log(res); 
                 return ++count;
             });
}, 0).then(console.log.bind(console, 'all done'));

这是我如何使用标准的 Promise 对象。

// Given async function sayHi
function sayHi() {
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log('Hi');
      resolve();
    }, 3000);
  });
}

// And an array of async functions to loop through
const asyncArray = [sayHi, sayHi, sayHi];

// We create the start of a promise chain
let chain = Promise.resolve();

// And append each function in the array to the promise chain
for (const func of asyncArray) {
  chain = chain.then(func);
}

// Output:
// Hi
// Hi (After 3 seconds)
// Hi (After 3 more seconds)

给定的

• asyncFn 函数
• 项目数组

必需的

• Promise链接 .then() 的串联（按顺序）
• 原生es6

解决方案

let asyncFn = (item) => {
  return new Promise((resolve, reject) => {
    setTimeout( () => {console.log(item); resolve(true)}, 1000 )
  })
}

// asyncFn('a')
// .then(()=>{return async('b')})
// .then(()=>{return async('c')})
// .then(()=>{return async('d')})

let a = ['a','b','c','d']

a.reduce((previous, current, index, array) => {
  return previous                                    // initiates the promise chain
  .then(()=>{return asyncFn(array[index])})      //adds .then() promise for each item
}, Promise.resolve())

有一种新方法可以解决这个问题，那就是使用 async/await。

async function myFunction() {
  while(/* my condition */) {
    const res = await db.getUser(email);
    logger.log(res);
  }
}

myFunction().then(() => {
  /* do other stuff */
})

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function https://ponyfoo.com/articles/understanding-javascript-async-await