递归承诺

Question

我在 database 中有 users 列表：

let users = []; // Please check the full list at the end of this post

这是我的 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;
};

这个函数return正确的结果。

[
  { 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] ] }
]

我不知道我错在哪里。能帮我看看吗？

让我们检查 users 数据：

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

您需要进行以下更改：

在您的 usrLst.forEach() 循环中，累积您获得的承诺列表，然后使用 Promise.all() 以便您知道它们何时全部完成。现在，您根本没有跟踪对 walkUsers() 的调用何时完成，因此，根据时间的不同，您可能会丢失或错过一些结果。
然后，您需要 return 来自您的 .then() 处理程序的主承诺，因此它被链接到父级 findUsers() 承诺 walkUsers() 是 returning。

可能看起来像这样：

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() 处理程序中 returned 以便内部异步操作链接到父操作，并且在所有嵌套异步操作完成之前，调用者不会被告知事情已完成。如果没有，该内部异步操作将变成一个独立的异步操作，它在自己的时间运行，上面没有任何东西等待它或与之协调，调用者是否看到它的结果将是时间运气的问题以及您的代码如何有效（这会产生不确定的结果）。

递归承诺

Promises Recursively

node.js

es6-promise

mongoose-populate