Node.js 承诺在Array.map之前返回。为什么？

我的代码中有两个函数；一个是获取保姆的名字，另一个是获取每个保姆的孩子的名字

我放的代码是一个模型，因为在现实世界中，我将它绑定到一个数据库，该数据库接受Sitter ID作为变量，并返回一个带有Sitter ID的子数据集。本质上，这是一个针对Sitter的数据库查询和一个针对Sitter的数据库查询

目标是在Sitters中循环并调用一个函数，传入Sitter ID，该ID将为我提供孩子

我想把孩子们添加到迭代的Sitter中

我的问题是，一旦获得了保姆，该计划就会终止，而不会让每个保姆都有孩子

我认为在我的坐椅上使用.map会导致代码等待拉动孩子的代码，但它会立即解决

我尝试了各种异步/等待和承诺组合，但我无法让它迭代Sitters，为每个Sitter轮询子项，然后返回填充子项的Sitters变量

const getSitters = () => {

    return new Promise((resolve) => {

        const sitters = [{

            id: 1,

            displayName: 'Sitter 1'

        }, {

            id: 2,

            displayName: 'Sitter 2'

        }];

        resolve({

            result: 'ok',

            sitters: sitters

        });

    });

};

const getChildrenBySitter = (getChildrenBySitterRequest) => {

    return new Promise((resolve) => {

        const children = [{

            id: 1,

            displayName: `Child 1 for Sitter ${getChildrenBySitterRequest.sitterId}`

        }, {

            id: 2,

            displayName: `Child 2 for Sitter ${getChildrenBySitterRequest.sitterId}`

        }];

        resolve({

            result: 'ok',

            children: children

        });

    });

};

getSitters().then((getSittersResponse) => {

    return getSittersResponse;

}).catch((getSittersResponse) => {

    return getSittersResponse;

}).then((getSittersResponse) => {

    const sitters = getSittersResponse.sitters;

    sitters.map(sitter => {

        const getChildrenBySitterRequest = {

            sitterId: sitter.id

        };

        getChildrenBySitter(getChildrenBySitterRequest).then((getChildrenBySitterResponse) => {

            return getChildrenBySitterResponse;

        }).catch((getChildrenBySitterResponse) => {

            return getChildrenBySitterResponse;

        }).then((getChildrenBySitterResponse) => {

            const children = getChildrenBySitterResponse.children;

            sitter.children = children;

        });

    });

    console.log(JSON.stringify(sitters));

});

我希望Sitters对象被迭代，并为每个Sitter填充子对象

---

如您所见，它在填充子对象之前返回Sitter对象，然后代码完成：

您必须在映射函数1中返回链接承诺，等待每个承诺得到履行2，然后记录sitters 3：

getSitters()
  .then(getSittersResponse => {
    return getSittersResponse;
  })
  .catch(getSittersResponse => {
    return getSittersResponse;
  })
  .then(getSittersResponse => {
    const sitters = getSittersResponse.sitters;

    Promise.all( // 2
      sitters.map(sitter => {
        const getChildrenBySitterRequest = {
          sitterId: sitter.id,
        };

        return getChildrenBySitter(getChildrenBySitterRequest) // 1
          .then(getChildrenBySitterResponse => {
            return getChildrenBySitterResponse;
          })
          .catch(getChildrenBySitterResponse => {
            return getChildrenBySitterResponse;
          })
          .then(getChildrenBySitterResponse => {
            const children = getChildrenBySitterResponse.children;

            sitter.children = children;
          });
      }),
    ).then(_ => {
      console.log(JSON.stringify(sitters)); // 3
    });
  });

输出：

[{"id":1,"displayName":"Sitter 1","children":[{"id":1,"displayName":"Child 1 for Sitter 1"},{"id":2,"displayName":"Child 2 for Sitter 1"}]},{"id":2,"displayName":"Sitter 2","children":[{"id":1,"displayName":"Child 1 for Sitter 2"},{"id":2,"displayName":"Child 2 for Sitter 2"}]}]

您还可以使用async和Wait：

const main = async () => {
  let sittersResponse;

  try {
    sittersResponse = await getSitters();
  } catch (ex) {
    console.error(ex);
    return;
  }

  const {sitters} = sittersResponse;

  for (let i = 0; i < sitters.length; i += 1) {
    const sitter = sitters[i];

    let response;

    try {
      response = await getChildrenBySitter({
        sitterId: sitter.id,
      });
    } catch (ex) {
      console.error(ex);
      return;
    }

    sitter.children = response.children;
  }

  console.log(JSON.stringify(sitters));
};

main();

---

谢谢你的帮助。我只是开始真正理解其中的一些概念，但我认为我已经了解了这个概念。它现在的工作情况和预期的一样。非常感谢您修改了我的代码，这样我就可以比较这两个代码，看看哪里出了问题。