Question

我试图以这种模式从它自己的回应中调用一个承诺函数：

f().then(function(response){
    if(response){
        f(response).then(function(response){
            if(response){
                f(response).then.....
            }
        });
    }
});

我正在使用angularjs。感谢。

P.S：

这个例子正在起作用，但第三个：

第一个例子：工作：

var a = ['one','two','four'];

angular.forEach(a, function(number){    
    f(number).then(function(response){
        console.log(response);
    }); 
});

第二个例子：工作：

var a = ['one','two','four'];

angular.forEach(a, function(number){
    f(number).then(function(response){
        if(response){
            f(response).then(function(response2){
                if(response2){
                    f(response2).then(function(response3){
                        console.log(response3); //this is the behaviour I'm trying to automate
                    });
                }
            });
        }
    });
});

第三个例子：不工作：

var a = ['one','two','four'];

angular.forEach(a, function(number){

    var t = '';

    f(number).then(function(response){
        t = response;
        while(t != ''){
            f(t).then(function(response){
                console.log(response);
                t = response;
            });
        }
    });
});

最后我这样做了：

var a=['one','two','four'];
var simple = function(token){
getasync(a[a.length-1], token).then(function(resptoken){
    console.log(resptoken);
    if(resptoken) 
        simple(resptoken);
    else if (a.length>1){ 
         a.pop() ;
         simple(resptoken);
    }else{
         console.log("theend");
    }
});
}

Answer 1

您应该执行类似

的操作

function call (response){
   f(response).then(function(response){
      if(response){
         call(response);
      }
   });
}

call(response);

如果承诺得到解决，它将再次自称

Answer 2

您正在询问如何创建一个承诺，其中最终解析依赖于异步服务中的一个或多个提取。事实上，在检查先前提取的数据之前，您不知道需要什么或多少后续提取。

这是受到严重诽谤的$q.defer()的工作。在你提问Is this a “Deferred Antipattern”?之前，请耐心等待我，并检查一下我的例子。

在我的示例中，我将计算 N factorial ，其中应用程序将 N 发送到服务器，以获取有关下一步操作的建议。（计算 N-1阶乘）。应用程序一直询问，直到它收到建议来计算它知道的 1 factorial 。

第一步是创建$q.defer并使用其中的promise来显示答案。

//Function to compute N! asynchronously
//
vm.asyncBangCompute = function(n) {

    var bangDefer = $q.defer();
    var bangPromise = bangDefer.promise;

    //Answer returned here
    //
    bangPromise.then ( function (answer) {
      vm.nAnswer = answer;
    }) .catch (function (error) {
      console.error(error);
    });

    vm.nBangSoFar = [];
    vm.nCompute = n;
    vm.nAnswer = "PENDING";

    asyncBangResolve(bangDefer, n, 1);
  };

接下来，解析器函数以递归方式调用伪HTTP服务及其自身，直到它解析答案。

//Recursively call the pseudoHttpService
//
function asyncBangResolve(defer, n, soFar) {
    if (n==1) {
      defer.resolve(soFar);
    } else {
      //push partial results
      vm.nBangSoFar.push(" "+(n*soFar)+" = "+n+"*"+soFar);
      //
      var nextPromise = pseudoHttpService(n,soFar);
      nextPromise.then (function (result) {
        asyncBangResolve(defer,result.data.n,result.data.soFar);
      });
    }
  }

DEMO on Plunker。

如何迭代递归承诺

2 个答案: