标签: angular-promise

有人可以解释Angular Promise和之间的区别Observable吗？

每个例子都有助于理解这两种情况.在什么情况下我们可以使用每个案例？

我有一个AngularJS服务,我想用一些异步数据进行初始化.像这样的东西:

myModule.service('MyService', function($http) {
    var myData = null;

    $http.get('data.json').success(function (data) {
        myData = data;
    });

    return {
        setData: function (data) {
            myData = data;
        },
        doStuff: function () {
            return myData.getSomeData();
        }
    };
});

显然这不会起作用,因为如果某些东西doStuff()在myData返回之前尝试调用,我将得到一个空指针异常.据我所知,从这里和这里提出的其他一些问题,我有几个选择,但没有一个看起来很干净(也许我错过了一些东西):

使用"运行"设置服务

设置我的应用时,请执行以下操作:

myApp.run(function ($http, MyService) {
    $http.get('data.json').success(function (data) {
        MyService.setData(data);
    });
});

然后我的服务看起来像这样:

myModule.service('MyService', function() {
    var myData = null;
    return {
        setData: function (data) {
            myData = data;
        },
        doStuff: function () {
            return myData.getSomeData();
        } …

给出AngularJS中的Ajax请求

$http.get("/backend/").success(callback);

如果启动另一个请求(相同的后端,例如不同的参数),取消该请求的最有效方法是什么.

我正在从Angular的文档中看到这个例子,$q但我认为这可能适用于一般的承诺.他们有这个例子,逐字复制他们的评论包括:

promiseB = promiseA.then(function(result) {
  return result + 1;
});

// promiseB will be resolved immediately after promiseA is resolved and its value
// will be the result of promiseA incremented by 1

我不清楚这是如何工作的.如果我可以调用.then()第一个的结果.then(),链接它们,我知道我可以,那么promiseB是一个类型的promise对象Object.它不是Number.那么他们的意思是"它的价值将是promiseA增加1的结果"？

我应该promiseB.value像那样访问它吗？成功回调如何返回一个承诺并返回"结果+ 1"？我错过了什么.

所以我有一种情况,我有多个未知长度的承诺链.我希望在处理完所有CHAINS后运行一些操作.这甚至可能吗？这是一个例子:

app.controller('MainCtrl', function($scope, $q, $timeout) {
    var one = $q.defer();
    var two = $q.defer();
    var three = $q.defer();

    var all = $q.all([one.promise, two.promise, three.promise]);
    all.then(allSuccess);

    function success(data) {
        console.log(data);
        return data + "Chained";
    }

    function allSuccess(){
        console.log("ALL PROMISES RESOLVED")
    }

    one.promise.then(success).then(success);
    two.promise.then(success);
    three.promise.then(success).then(success).then(success);

    $timeout(function () {
        one.resolve("one done");
    }, Math.random() * 1000);

    $timeout(function () {
        two.resolve("two done");
    }, Math.random() * 1000);

    $timeout(function () {
        three.resolve("three done");
    }, Math.random() * 1000);
});

在这个例子中,我设置了一个$q.all()承诺一,二和三,这将在一些随机时间得到解决.然后我将承诺添加到第一和第三的末尾.我想要all解决所有链都已解决的问题.这是我运行此代码时的输出:

one done 
one doneChained …

我有一个Promise.我创建它以在需要时取消AJAX请求.但是因为我不需要取消那个AJAX,所以我从未解决它并且AJAX成功完成.

一个简化的片段:

var defer = $q.defer();
$http({url: 'example.com/some/api', timeout: defer.promise}).success(function(data) {
    // do something
});

// Never defer.resolve() because I don't need to cancel that ajax. What happens to this promise after request?

永远不会解决这样的承诺导致内存泄漏？您对如何管理Promise生命周期有什么建议吗？

我希望有一个for循环,每次迭代都会调用异步函数.

在for循环之后,我想执行另一个代码块,但是在for循环中所有先前的调用都已解决之前.

我现在的问题是,在所有异步调用完成之前执行for循环之后的代码块或者根本不执行它.

带有FOR循环的代码部分和后面的代码块(完整代码,请参见小提琴):

[..]
function outerFunction($q, $scope) {
    var defer = $q.defer();    
    readSome($q,$scope).then(function() {
        var promise = writeSome($q, $scope.testArray[0])
        for (var i=1; i < $scope.testArray.length; i++) {
             promise = promise.then(
                 angular.bind(null, writeSome, $q, $scope.testArray[i])
             );                                  
        } 
        // this must not be called before all calls in for-loop have finished
        promise = promise.then(function() {
            return writeSome($q, "finish").then(function() {
                console.log("resolve");
                // resolving here after everything has been done, yey!
                defer.resolve();
            });   
        });        
    });   

    return defer.promise;
}

我创建了一个jsFiddle,可以在这里找到http://jsfiddle.net/riemersebastian/B43u6/3/. …

我们在Angular应用程序中有一个解决承诺的模式,直到Angular 1.6.0为止我们一直很好:

    resource.get().$promise
        .then(function (response) {
        // do something with the response
        }, function (error) {
            // pass the error the the error service
            return errorService.handleError(error);
        });

以下是我们如何在Karma中触发错误:

    resourceMock.get = function () {
        var deferred = $q.defer();
        deferred.reject(error);
        return { $promise: deferred.promise };
    };

现在,随着1.6.0的更新,Angular突然抱怨我们的单元测试(在Karma中)因"可能未处理的拒绝"错误而被拒绝的承诺.但是我们正在处理调用错误服务的第二个函数中的拒绝.

Angular究竟在寻找什么？它是如何让我们"处理"拒绝的？

当使用AngularJS"http get then"构造(promises)时,如何处理HTTP错误,例如500？

$http.get(url).then(
    function(response) {
        console.log('get',response)
    }
)

问题是,对于任何非200 HTTP响应,都不会调用内部函数.

当一些调用工作而其他调用失败时,$ q.all()会发生什么？

我有以下代码:

    var entityIdColumn = $scope.entityType.toLowerCase() + 'Id';
    var requests = $scope.grid.data
      .filter(function (rowData, i) {
          return !angular.equals(rowData, $scope.grid.backup[i]);
      })
      .map(function (rowData, i) {
          var entityId = rowData[entityIdColumn];
          return $http.put('/api/' + $scope.entityType + '/' + entityId, rowData);
      });
    $q.all(requests).then(function (allResponses) {
        //if all the requests succeeded, this will be called, and $q.all will get an
        //array of all their responses.
        console.log(allResponses[0].data);
    }, function (error) {
        //This will be called if $q.all finds any of the requests erroring.
        var abc …