AngularJS：对服务函数的多次调用返回单独的承诺

Question

好的，这是对先前问题的重新发布，我因过度简化代码而感到困惑......

我有一个 angularjs 工厂函数，它查询解析数据库，并返回一个承诺......到目前为止，非常简单......但是，我的控制器有一个 foreach 循环，它为一系列 id 中的每一个调用该函数，这意味着然后同时解决。但是，解析不起作用，我得到的似乎是 api 调用的乱码。

这是我的代码的简化版本...

app.factory('MyFactory', function($http, $q ) {
  return {
    testFunction: function (ingredientList) {

      var deferred = $q.defer()

      ingredientIndex=-1

      var regulariseIngredient=function() {

        ingredientIndex++

        if (ingredientIndex>ingredientList.length-1) {
          deferred.resolve(ingredientList);
          return
        }

        (new Parse.Query("Ingredient"))
        .equalTo("type", ingredientList[ingredientIndex].type)
        .equalTo("name", ingredientList[ingredientIndex].name)
        .include("parent")
        .find().then(function(result) {
          result=result[0]
          if(result.get("parent")) result=result.get("parent")                        
          ingredientList[ingredientIndex]=result
          regulariseIngredient();
         })                               

       }
       regulariseIngredient()
       return deferred.promise
    }
  }
}

app.controller('TestController', function($scope,MyFactory) {
  recipes = [ An array of objects, each with an ingredients array]
  angular.forEach(recipes, function(recipe) { 
    MyFactory.testFunction(recipe.ingredients).then(function(result) {
      console.log(result)
    })
  })
} 

有关该服务实际作用的更多信息...

我的应用包含一组食谱和一组配料。每种成分都有一个“父母”，可以在“合理化”版本中替代它。测试函数循环遍历每个成分，编译结果，然后返回替换成分的集合。控制器正在循环遍历食谱，以便我可以检查所有食谱的手头成分。

Answer 1

@MarkPeace，您似乎在“The Collection Kerfuffle”标题下点击了“非法”here 的反模式。

支持的模式（用于在项目数组的每个成员上并行执行异步任务）是：

function workMyCollection(arr) {
    return q.all(arr.map(function(item) {
        return doSomethingAsync(item);
    }));
}

在你的情况下，doSomethingAsync() 是 (new Parse.Query("Ingredient"))...find();

完整的代码如下：

app.factory('MyFactory', function($http, $q) {
    return {
        testFunction: function (ingredientList) {
            return $q.all(ingredientList.map(function(item) {
                return (new Parse.Query("Ingredient"))
                    .equalTo("type", item.type)
                    .equalTo("name", item.name)
                    .include("parent")
                    .find().then(function(result) {
                        return result[0].get("parent") || result[0];//phew, that's a bit more concise
                    });
            }));
        }
    }
}); 

testFunction() 将因此返回一组结果的承诺（无论结果如何）。

在控制器中，您可以再次使用相同的模式来循环遍历配方：

app.controller('TestController', function($scope, MyFactory) {
    var recipes = [ An array of objects, each with an ingredients array ];
    $q.all(recipes.map(function(recipe) {
        return MyFactory.testFunction(recipe.ingredients).then(function(results) {
            console.dir(results);
            return results;
        });
    })).then(function(arr) {
        //all done-and-dusted
        //If everything has been successful, arr is an array of arrays of results
        //Do awesome stuff with the data.
    })['catch'](function(err) {
        //report/handle error here
    });
});

当然，您在控制器中执行多少操作以及在工厂（或多个工厂）执行多少操作取决于您。就个人而言，我会选择让控制器稍微简单一些。

Answer 2

使用 $q.all() 将一组承诺作为参数并返回一个新的承诺：

• 如果数组的所有承诺都已解决，则已解决
• 如果数组的任何承诺被拒绝，则被拒绝

来自文档：

返回一个单一的promise，它将用一个数组/哈希值解析，每个值对应于promise数组/哈希中相同索引/键的promise。如果任何一个 Promise 以一个拒绝的方式解决，这个产生的 Promise 将以相同的拒绝值被拒绝。

对于循环，使用 Array.forEach 更干净：

testFunction:     function (ingredientList) {
    var promiseArray = [];

    ingredientList.forEach(function (ingredient) {
        var promise = (new Parse.Query("Ingredient"))
                .equalTo("type", ingredient.type)
                .equalTo("name", ingredient.name)
                .include("parent")
                .find().then(function(result) {
                    result = result[0]
                    if(result.get("parent")) {
                        result = result.get("parent");
                    }
                    return result;
                });
        promiseArray.push(promise);
    });

    return $q.all(promiseArray);
}