node.js - 递归 promise

Question

我在数据库中有用户列表:

让用户 = [];//请查看本文末尾的完整列表

这是我的 findUsers 函数:(这个函数看起来像从数据库中搜索。但我只是用硬编码数据编写了简单的函数)

function findUsers(user) {
  return new Promise(function (resolve) {
    resolve(user.users);
  });
}

我想获取以 userId 开头的所有用户:

const walkUsers = (user, list) => {
  let usrLst = user.users;
  list = list || [];
  usrLst.forEach((usr) => {
    if (usr.users.length > 0) {
      list = walkUsers(usr, list);
    }
    list.push(usr);
  });
  return list;
};

该函数返回正确的结果。

[
  { id: '009', name: 'User 9', users: [] },
  { id: '011', name: 'User 11', users: [] },
  { id: '010', name: 'User 10', users: [ [Object] ] },
  { id: '004', name: 'User 4', users: [ [Object], [Object] ] },
  { id: '003', name: 'User 3', users: [ [Object] ] },
  { id: '007', name: 'User 7', users: [] },
  { id: '002', name: 'User 2', users: [ [Object], [Object] ] },
  { id: '008', name: 'User 8', users: [] },
  { id: '005', name: 'User 5', users: [ [Object] ] },
  { id: '006', name: 'User 6', users: [] }
]

但这不是我的预期。我想从数据库(Mongoose)获取数据

const walkUsers = (user, list) => {
  return findUsers(user)
    .then((usrLst) => {
      list = list || [];
      usrLst.forEach((usr) => {
        if (usr.users.length > 0) {
          walkUsers(usr, list).then((rtnLst) => {
            console.log("rtnLst");
            console.log(rtnLst);
            return rtnLst;
          });
        }
        list.push(usr);
      });

      return list;
    });
};

此函数缺少用户009、010、011

[
  { id: '002', name: 'User 2', users: [ [Object], [Object] ] },
  { id: '005', name: 'User 5', users: [ [Object] ] },
  { id: '006', name: 'User 6', users: [] },
  { id: '003', name: 'User 3', users: [ [Object] ] },
  { id: '007', name: 'User 7', users: [] },
  { id: '008', name: 'User 8', users: [] },
  { id: '004', name: 'User 4', users: [ [Object], [Object] ] }
]

我不知道我错了什么。能帮我查一下吗？

让我们检查用户数据:

let users = [
  {
    id: '001',
    name: 'User 1',
    users: [
      {
        id: '002',
        name: 'User 2',
        users: [
          {
            id: '003',
            name: 'User 3',
            users: [
              {
                id: '004',
                name: 'User 4',
                users: [
                  {
                    id: '009',
                    name: 'User 9',
                    users: []
                  },
                  {
                    id: '010',
                    name: 'User 10',
                    users: [
                      {
                        id: '011',
                        name: 'User 11',
                        users: []
                      },
                    ]
                  },
                ]
              }
            ]
          },
          {
            id: '007',
            name: 'User 7',
            users: []
          }
        ]
      },
      {
        id: '005',
        name: 'User 5',
        users: [
          {
            id: '008',
            name: 'User 8',
            users: []
          }
        ]
      },
      {
        id: '006',
        name: 'User 6',
        users: []
      },
    ]
  },
];

Answer 1

您需要进行以下更改:

1. 在您的 usrLst.forEach() 循环中，累积您获得的 Promise 列表，然后使用 Promise.all() 以便您知道它们何时全部完成。目前，您根本无法跟踪对 walkUsers() 的调用何时完成，因此，根据时间的不同，您可能会丢失或错过一些结果。
2. 然后，您需要从 .then() 处理程序返回该主 Promise，以便将其链接到 walkUsers() 返回的父 findUsers() Promise。

可能看起来像这样:

const walkUsers = (user, list) => {
  return findUsers(user)
    .then((usrLst) => {
      list = list || [];
      var promises = [];
      usrLst.forEach((usr) => {
        if (usr.users.length > 0) {
          promises.push(walkUsers(usr, list));
        }
        list.push(usr);
      });

      return Promise.all(promises).then(function() {
          // make the list be the resolved value from this promise
          return list;
      });
    });
};

请记住，任何时候在 .then() 处理程序中进行异步操作时，几乎总是应该从 .then() 处理程序返回一个 Promise，以便内部异步操作链接到父操作，并且在所有嵌套异步操作完成之前，调用者不会被告知事情已完成。如果不是，该内部异步操作只会成为一个孤立的异步操作，它按自己的时间运行，上面没有任何东西等待它或与其协调，调用者是否看到其结果将取决于时间运气和代码如何工作的问题(这会产生不确定的结果)。