NodeJs：等待 ForEach 函数

Question

我编写了一个验证函数，我想检查一个数组是否可以插入。我想返回多个错误。 我搜索了该主题，但无法通过承诺异步模块运行它。 我对 NodeJS 很陌生，如果您能帮助我，我将不胜感激。

function validateNewResultUnits(sets, req) {
  var validate = [];
  sets.forEach(function(setItem) {
    setItem.forEach(function(item) {
      if (item.hasOwnProperty("name") == false) {
        validate.push({
          'name': 'Name has to be set'
        });
      } else {
        if (item.name === "" || item.name === null || item.name === undefined) {
          validate.push({
            'name': 'Name cannot be empty'
          });
        } else {
          Exercise.forge({
            name: req.body.name
          }).fetch({
            withRelated: [{
              'resultUnits': function(qb) {
                qb.where('name', item.name);
              }
            }]
          }).then(function(exercise) {
            console.log("Länge:" + exercise.related('resultUnits').length);
            if (exercise.related('resultUnits').length === 0)
              validate.push({
                'name': 'ResultUnit not found'
              });
          }).catch(function(error) {
            validate.push({
              'name': 'An Error occured'
            });
          });
        }
      }

      if (item.hasOwnProperty("value") == false) {
        validate.push({
          'value': 'Value has to be set'
        });
      } else {
        if (item.value === "" || item.value === null || item.value === undefined) {
          validate.push({
            'value': 'Name cannot be empty'
          });
        } else {
          if (isNaN(item.value)) validate.push({
            'value': 'Value has to be number'
          });
        }
      }
    });
  });
  return validate;
}

var validate = validateNewResultUnits(req.body.sets, req);
console.log(validate);
if (validate.length == 0) {
  // ...
}

console.log(validate); 在函数准备好返回之前返回 undefined。 非常感谢。

编辑： Promise Attempt（在第二个 forEach 内）

var promise = new Promise(function(resolve) {
                                Exercise.forge({name: req.body.name })
                                .fetch({
                                    withRelated: [{'resultUnits': function(qb) {
                                        qb.where('name',item.name)
                                    }}]
                                }).then(function(exercise) { 
                                console.log("Länge:"+exercise.related('resultUnits').length);
                                if (exercise.related('resultUnits').length === 0)
                                    resolve({'name':'ResultUnit not found'});
                                }).catch(function(error) { resolve({'name': 'An Error occured'}); });
                            });
                            promise.then(function(result) {
                                validate.push(result);
                            });

Answer 1

问题在于Exercise.forge({name: req.body.name }).fetch(...)，因为它异步运行，这使得validateNewResultUnits 函数继续执行，直到它返回未定义的结果。

我建议您更改该代码以包含 Promise 而不是那些丑陋的异步回调，这将需要更改 validateNewResultUnits 函数本身及其任何调用者。这里有一些资源可以帮助你快速理解 Promise：

https://strongloop.com/strongblog/promises-in-node-js-with-q-an-alternative-to-callbacks/

Understanding promises in node.js

http://howtonode.org/promises

https://vimeo.com/144550711

https://vimeo.com/144550811

https://vimeo.com/144550913

---

编辑

这是所提供代码的副本，但使用了 Promise

function validateNewResultUnits(sets, req) {
  return new Promise(function(resolve, reject){
    var validate = [];
    var internalPromises = [];
    sets.forEach(function(setItem) {
      setItem.forEach(function(item) {
        if (item.hasOwnProperty("name") == false) {
          validate.push({'name': 'Name has to be set'});
        } else {
          if (item.name === "" || item.name === null || item.name === undefined) {
            validate.push({'name': 'Name cannot be empty'});
          } else {
            var internalPromise = Exercise.forge({name: req.body.name}).fetch({
                withRelated: [{
                  'resultUnits': function (qb) {
                    qb.where('name', item.name);
                  }
                }]
              });
            internalPromise.then(function(exercise) {
              console.log("Länge:" + exercise.related('resultUnits').length);
              if (exercise.related('resultUnits').length === 0)
                validate.push({'name': 'ResultUnit not found'});
            }).catch(function(error) {
              validate.push({'name': 'An Error occured'});
            });
            internalPromises.push(internalPromise);
          }
        }

        if (item.hasOwnProperty("value") == false) {
          validate.push({'value': 'Value has to be set'});
        } else {
          if (item.value === "" || item.value === null || item.value === undefined) {
            validate.push({'value': 'Name cannot be empty'});
          } else {
            if (isNaN(item.value))
              validate.push({'value': 'Value has to be number'});
          }
        }
      });
    });

    if(internalPromises && internalPromises.length) {
      Promise.all(internalPromises).then(function (value) {
        console.log(value);
        resolve(validate);
      }, function (reason) {
        console.log(reason);
        resolve(validate);
      });
    } else {
      resolve(validate);
    }
  });
}

var validatePromise = validateNewResultUnits(req.body.sets, req);
validatePromise.then(function(result){
  console.log(result);
  if (result.length == 0) {
    // ...
  }
});