嵌套的循环转换为嵌套的承诺

第一：您的代码从根本上来说是有缺陷的

我之所以说根本有缺陷，是因为您似乎误解了functions工作原理

return Promise.map(nameList, function(personName){  <-- this function 
  for (var j=1; j<=10; j++){
    return promises.push(new Promise(function(resolve, reject) { <-- is returning HERE

在此Array.prototype.push函数返回index新添加项目的。（我查了一下，直到）
此处最大的问题是您要退货。

您return的mapper功能Promise.map告诉您完成了！因此，在上面的代码中，它甚至无法到达for loop

在MDN中查找规格return说明

return语句结束函数执行并指定要返回给函数调用者的值。

希望这可以回答您的问题，以便早日返回。

---

第二：我不会指望你的承诺

我自己也很难兑现承诺。让我引导您阅读有关我最近阅读的承诺的精彩文章。现在让我运用从中学到的东西。谢谢你这个问题。

我们承诺要与回调地狱作斗争，但您将它的目的全部串了起来。

我会尝试从最嵌套的部分开始兑现承诺

SOME_SEARCH_FX_THAT_RETURNS_A_PROMISE(params).then(function(data){
    return Promise.map(data, function(item, index){
        if (!_.has(jsonDict, item.key)){
            jsonDict[item.key] = {
                name: personName
            }
        }
        return
    }).then(function(){
        console.log(jsonDict)
        return resolve(true)
    })

}).catch(function(err){
    console.log(err)
    return reject(false)
})

这里的内部诺言图是不必要的，您甚至可以使用一个标准map，for loop因为您实际上并没有在这里映射任何东西。

[重构1]

// Create subroutine, careful with the globals...
let populateJsonDict = singleData => {
  if (!_.has(jsonDict, singleData.key)) jsonDict[singleData.key] = { name: personName }
}

SOME_SEARCH_FX_THAT_RETURNS_A_PROMISE(params).then(data => {
    data.forEach(populateJsonDict);
    resolve(true); // this will be removed later
}).catch(function(err){
    console.log(err);
    reject(false); // this will be removed later
})

好吧，让我们向上移动回调金字塔（或向下移动？）。清单上的下一个

for (var j=1; j<=10; j++){
  return promises.push(new Promise(function(resolve, reject) {
    params['page'] = j;

    console.log('PAGE ' + j + ' ' + personName)

    //[Refactored 1]
  }))
}

再次在这里另一个不必要的承诺，是时候摆脱它了。而这个问题的基石return

[重构2]

for (var j=1; j<=10; j++){
  //[from Refactored 1]
  let populateJsonDict = singleData => {
    if (!_.has(jsonDict, singleData.key)) jsonDict[singleData.key] = { name: personName }
  }
  params['page'] = j; // I assume this a global somewhere
  let p = SOME_SEARCH_FX_THAT_RETURNS_A_PROMISE(params).then(data => {
    data.forEach(populateJsonDict);
    // Removed because we've removed the parent promise
  }).catch(function(err){
    console.log(err);
    // Removed because we've removed the parent promise
  })
  promises.push(p)
}

我快进，因为我注意到这已经很长了。下一块重构

return new Promise((res, rej) => {
    var promises = [];
    return Promise.map(nameList, function(personName){
      //[Refactored 2]
    }).then(function(){
      return res(true)
    })
}).then(function(){
    console.log('Done with everything.')
})

我真的不知道该如何解决这个问题，所以我会分组讨论。

[Refactor 3：final]

var promises = [];
nameList.forEach(personName => { // Like earlier, redundant Promise.map
  //[from Refactored 2]
  for (var j=1; j<=10; j++){
    let populateJsonDict = singleData => {
        if (!_.has(jsonDict, singleData.key)) jsonDict[singleData.key] = { name: personName }
    }
    params['page'] = j;
    let p = SOME_SEARCH_FX_THAT_RETURNS_A_PROMISE(params).then(data => {
        data.forEach(populateJsonDict);
    }).catch(function(err){
        console.log(err);
    })
    promises.push(p)
  }
});
// At this point you have an array of Promises, for this we can utilize Promise.all

Promise.all(promises)
    .then(() => console.log('Done with Everything'));

我想可以做得更好。让我做一个最后的版本。

[重构3.1：最终]

let populateJsonDict = name => key => !_.has(jsonDict, key) && Object.assign(jsonDict, {[key]:name};
let promises = _.times(10, 
    index => {
        params['page'] = index+1;
        return Promise.map(nameList, name => {
            let populateWithName = populateJsonDict(name);
            let iterate = data => data.forEach(populateWithName);
            return SOME_SEARCH_FX_THAT_RETURNS_A_PROMISE(params)
                .then(iterate)
                .catch(err => console.log(err));
        });
    });

Promise.all(promises)
    .then(() => console.log('Everything done'));

好吧，仍然有这种不满意的感觉，但这就是我现在要面对的……对我来说，确实比你更多。再次感谢您的朋友。我希望我们俩都能继续前进，因为这是一个日新月异的工作领域。抱歉，无论如何这一切听起来都很屈服。干杯!