Javascript 如何打印来自Promise函数的结果

我刚刚开始学习Promises，我得到的控制台结果是[Promise{pending}]我想打印函数的确切结果，有人能帮我吗

exports.listProjectRepos1 = (req, res)=> {
    let pID = mongoose.Types.ObjectId(req.params.projectId);
    console.log("User Id is ", req.user._id);
    let query = {
        userID: mongoose.Types.ObjectId(req.user._id),
        projectID: pID
    };
        RepositoriesSchema.find(query).lean().then((repos)=> {
            return repos
        }).then((repos)=> {
            let roots = repos.map(exports.populateCodestack1);
            console.log(roots);// trying to Print the Results here
        });
};


exports.populateCodestack1 = function (repo) {
    return new Promise((resolve, reject)=> {
        Promise.all([new Promise((resolve, reject)=> {
            let codeId = repo.codeStack;
            CodeStacksSchema.findOne({ID: codeId}).lean().exec(function (err, codeStack) {
                if (codeStack) {
                    repo.stack = codeStack.name;
                    resolve(repo)
                }
            });
        }),
            new Promise((resolve, reject)=> {
                let owner = mongoose.Types.ObjectId(repo.SCMAccount);
                console.log("Owner Id is", owner);
                ScmaAccount.findOne({_id: owner}).lean().exec(function (err, scm) {
                    if (scm) {
                        repo.type = scm.type;
                        resolve(repo);
                    }
                });
            })

        ]).then(function (result1) {
           // console.log("Refresh Result",result);
            resolve(result1);
        })
    })
};

---

我想打印函数的输出。

导出。populateCodestack1

返回承诺，因此

根将包含承诺列表

如果要等待数组中的所有承诺都解决，则将其传递给
Promise.all

RepositoriesSchema.find(query).lean()
  .then( repos => Promise.all(repos.map(exports.populateCodestack1)) )
  .then( roots => {
    console.dir(roots);
  });

除此之外：如果使用
new Promise
，则应处理错误情况，并且仅当需要包装不支持承诺的函数时，才使用
new Promise
，但决不包装现有承诺对象：

exports.populateCodestack1 = function(repo) {
  return Promise.all([
    new Promise((resolve, reject) => {
      let codeId = repo.codeStack;
      CodeStacksSchema.findOne({
        ID: codeId
      }).lean().exec(function(err, codeStack) {
        if (err) {
          reject(err);
        } else {
          repo.stack = codeStack.name;
          resolve(repo)
        }
      });
    }),
    new Promise((resolve, reject) => {
      let owner = mongoose.Types.ObjectId(repo.SCMAccount);
      console.log("Owner Id is", owner);
      ScmaAccount.findOne({
        _id: owner
      }).lean().exec(function(err, scm) {
        if (err) {
          reject(err)
        } else {
          repo.type = scm.type;
          resolve(repo);
        }
      });
    })
  ])
};

编辑

由于mongoose lib已经支持Promissions，因此应该可以使用以下方法进一步简化它：

exports.populateCodestack1 = function(repo) {
  return Promise.all([
    CodeStacksSchema.findOne({
      ID: repo.codeStack
    }).lean().then(codeStack => {
      repo.stack = codeStack.name;
      return repo
    }),
    ScmaAccount.findOne({
      _id: mongoose.Types.ObjectId(repo.SCMAccount)
    }).lean().then(scm => {
      repo.type = scm.type;
      resolve(repo);
    })
  ])
};

exports.populateCodestack1
返回一个承诺，因此
root
将包含一个承诺列表

如果要等待数组中的所有承诺都解决，则将其传递给
Promise.all

RepositoriesSchema.find(query).lean()
  .then( repos => Promise.all(repos.map(exports.populateCodestack1)) )
  .then( roots => {
    console.dir(roots);
  });

除此之外：如果使用
new Promise
，则应处理错误情况，并且仅当需要包装不支持承诺的函数时，才使用
new Promise
，但决不包装现有承诺对象：

exports.populateCodestack1 = function(repo) {
  return Promise.all([
    new Promise((resolve, reject) => {
      let codeId = repo.codeStack;
      CodeStacksSchema.findOne({
        ID: codeId
      }).lean().exec(function(err, codeStack) {
        if (err) {
          reject(err);
        } else {
          repo.stack = codeStack.name;
          resolve(repo)
        }
      });
    }),
    new Promise((resolve, reject) => {
      let owner = mongoose.Types.ObjectId(repo.SCMAccount);
      console.log("Owner Id is", owner);
      ScmaAccount.findOne({
        _id: owner
      }).lean().exec(function(err, scm) {
        if (err) {
          reject(err)
        } else {
          repo.type = scm.type;
          resolve(repo);
        }
      });
    })
  ])
};

编辑

由于mongoose lib已经支持Promissions，因此应该可以使用以下方法进一步简化它：

exports.populateCodestack1 = function(repo) {
  return Promise.all([
    CodeStacksSchema.findOne({
      ID: repo.codeStack
    }).lean().then(codeStack => {
      repo.stack = codeStack.name;
      return repo
    }),
    ScmaAccount.findOne({
      _id: mongoose.Types.ObjectId(repo.SCMAccount)
    }).lean().then(scm => {
      repo.type = scm.type;
      resolve(repo);
    })
  ])
};

。然后（（repos）=>{return repos}）
是多余的。@DanielB是的，我一开始没看到，代码有点乱。@DanielB你能解释一下它是怎么多余的吗。。我只是说学习。你能再解释一下吗？@Jeevan看着你的代码
RepositoriesSchema.find（query.lean（）.then（（repos）=>{return repos}.then（（repos）
很明显，
.lean（）
将
repos
对象返回到下面的
。然后（）。因此，询问为什么你应该有第二个<代码>。（，）/代码>在所有的中间，只返回<代码> RePOS < /代码>。这就像编写函数<代码>函数（x）{返回x；} >代码> >（（RePOS）= > {Real-RePoS}）
是多余的。@DanielB是的，一开始我没有看到，代码有点凌乱。@DanielB你能解释一下它是怎么多余的吗..我刚刚说了学习。你能不能再解释一下。@Jeevan看着你的代码
RepositoriesSchema.find（query.lean（）。然后（（repos）=>{return repos}）。然后（（repos）应该很明显，<代码> .Lead（）/代码>将<代码> RePOS 对象返回到下面的<代码>。（）（代码）>因此，询问为什么应该有第二个<代码>。（）（代码）>所有的，只是返回<代码> RePOS < /代码>。这就像编写函数<代码>函数（x）{返回x；}。
。避免！简单地
回报承诺。所有（…）
，不要用任何东西包装它。如果出现错误，不要忘记
拒绝你的承诺。避免！简单地
回报承诺。所有（…）
，不要用任何东西包装它。如果出现错误，不要忘记
拒绝你的承诺。