标签: angular-promise

在下面的代码片段error 1,并success 2会被记录.如果原始延迟被拒绝,我怎样才能传播被调用的错误回调而不是被调用的成功回调.

angular.module("Foo", []);
angular
.module("Foo")
.controller("Bar", function ($q) {
    var deferred = $q.defer();
      deferred.reject();

      deferred.promise
          .then(
              /*success*/function () { console.log("success 1"); },
              /*error*/function () { console.log("error 1"); })
          .then(
              /*success*/function () { console.log("success 2"); },
              /*error*/function () { console.log("error 2"); });
});

<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.23/angular.min.js"></script>
<div ng-app="Foo">
    <div ng-controller="Bar"></div>
</div>

我试图拦截401和403错误刷新用户令牌,但我不能让它运作良好.我所取得的就是这个拦截器:

app.config(function ($httpProvider) {

  $httpProvider.interceptors.push(function ($q, $injector) {

    return {
      // On request success
      request: function (config) {
        var deferred = $q.defer();

        if ((config.url.indexOf('API URL') !== -1)) {
          // If any API resource call, get the token firstly
          $injector.get('AuthenticationFactory').getToken().then(function (token) {
            config.headers.Authorization = token;

            deferred.resolve(config);
          });
        } else {
          deferred.resolve(config);
        }

        return deferred.promise;
      },

      response: function (response) {
        // Return the promise response.
        return response || $q.when(response);
      },

      responseError: function (response) {
        // Access token invalid …

Angular2中Angular的$ q相当于什么？具体来说,我正在寻找$q.when,这让你做了类似的事情:

return $q.when(['TestResponse']);

新的TypeScript异步/等待功能使用ES6承诺.AngularJS使用$q略有不同的接口的服务承诺.

有没有办法使用TypeScript async/await功能与$q服务承诺？

在以下代码中,$ q promise 的catch函数捕获异常:

// Fiddle - http://jsfiddle.net/EFpn8/6/
f1().then(function(data) {
        console.log("success 1: "+data)
        return f2();
    })
    .then(function(data) {console.log("success 2: "+data)})
    .catch(function(data) {console.log("error: "+data)});

function f1() {
    var deferred = $q.defer();
    // An exception thrown here is not caught in catch
    // throw "err";
    deferred.resolve("done f1");        
    return deferred.promise;
}

function f2() {
    var deferred = $q.defer();
    // An exception thrown here is handled properly
    throw "err";
    deferred.resolve("done f2");        
    return deferred.promise;
}  

但是,当我查看控制台日志输出时,我看到以下内容:

该异常是在Angular中捕获的,但也被浏览器的错误处理所捕获.此行为确实与Q库重现.

这是一个错误吗？我怎样才能真正捕获$ q的异常？

如何在Angularjs拦截器中停止请求.

有没有办法做到这一点？

我尝试使用promises并发送拒绝而不是解决!

.factory('connectionInterceptor', ['$q', '$timeout',
   function($q, $timeout) {
    var connectionInterceptor = {
        request: function(config) {
            var q = $q.defer();
            $timeout(function() {
                q.reject();
            }, 2000)
            return q.promise;
            // return config;
        }
    }
    return connectionInterceptor;
  }
])
.config(function($httpProvider) {
   $httpProvider.interceptors.push('connectionInterceptor');
});

我有一个对象列表.对象将传递给延迟函数.我想在解析前一个调用后才调用具有下一个对象的函数.有什么方法可以做到这一点吗？

angular.forEach(objects, function (object) {
    // wait for this to resolve and after that move to next object
    doSomething(object);
});

我发现很难理解"延迟反模式".我认为我原则上理解它,但我没有看到一个超级简单的例子,一个服务,一个不同的承诺和一个反模式,所以我想我会尝试自己做但看到我不是超级了解它我先得到一些澄清.

我在工厂(SomeFactory)中有以下内容:

//url = 'data.json';

return {
    getData: function(){
        var deferred = $q.defer();

        $http.get(destinationFactory.url)
            .then(function (response) {

                if (typeof response.data === 'object') {
                    deferred.resolve(response.data);
                } else {
                    return deferred.reject(response.data);
                }
            })

            .catch(function (error) {
            deferred.reject(error);
        });

        return deferred.promise;
    }

我检查它的对象的原因只是在上面添加一个简单的验证层 $http.get()

以下,在我的指令中:

this.var = SomeFactory.getData()
    .then(function(response) {
        //some variable = response;
    })
    .catch(function(response) {
        //Do error handling here
});

现在我的理解是,这是一个反模式.因为原始的延期承诺会捕获错误并简单地吞下它.它不会返回错误,因此当调用此"getData"方法时,我已经执行了另一个捕获错误的捕获.

如果这不是反模式,那么有人可以解释为什么两者都要求各种"回调"吗？当我第一次开始写这个工厂/指令时,我预计不得不在某个地方做一个默认的承诺,但我没有预料到必须.catch()在两边(也就是我有点想我可以让工厂返回响应或错误,如果我做了一个SomeFactory.getData()

我现在已经阅读了大约$ q和承诺几天了,我似乎也明白了...... 我在实践中遇到以下情况:

1. 发出$ http请求并检查是否可以进行后续调用.

2. 如果第一次呼叫失败,则返回"无数据",如果成功并表示可以进行呼叫,则进行第二次呼叫,如果不​​成功,则再次进行"无数据".如果第二次调用成功,则返回数据,如果不是 - "无数据".它看起来像这样(大约,我简化了一般的想法,所以不要担心这里的小错误):

           return $http.get (something)
               .then(function(allowedAccess){
                   if(allowedAccess){
                       return $http.get (somethingElse)
                           .then( function(result){return {data:result} },
                           function(error){return {data:"n0pe"} }
                       )
                   } else {
                       return {data:"n0pe"}
                   }
               },
               function(){ return {data:"n0pe"} });
   

   Run Code Online (Sandbox Code Playgroud)

有人告诉我在这里使用$ q.我真的不明白我会怎样或为什么.$ http电话已经是承诺.

如果有办法使这个更清洁,我没有看到它.刚刚完成了关于这个主题的重新阅读这篇文章.基本上,我错过了什么/有没有更好的方法来做到这一点？

编辑:也只是重新阅读链接承诺的教程 - 它根本不处理呼叫失败.基本上将此作为尽职调查发布.

编辑2:这更详细地阐述了我要问的理论,摘自第一篇文章:

这是一个简单的例子.如果你的then()回调返回另一个promise,它会变得非常强大.在这种情况下,下一个then()只会在承诺结算后执行.例如,此模式可用于串行HTTP请求(请求取决于前一个请求的结果):

这似乎是在谈论像这样的链:

   asyncFn1(1)
    .then(function(data){return asyncFn2(data)})
    .then(function(data){return asyncFn3(data)})

所以,如果我理解正确这一点a).不适用于我,因为我没有第三功能.B).如果我有三个函数会适用于我,因为当我在第一个$ http请求中运行if语句时,只有在if语句中我才会返回另一个promise.所以,理论上,如果我有三个异步函数来链接,我需要将我的if语句放在一个promise中吗？

我观察到在角度2中,promise API没有finally块

角1:

 loadUsers() {
  fetch('/api/users').then((response) => {
    return response.json();
  }).then((data) => {
    this.users = data;
  }).catch((ex) => {
    console.error('Error fetching users', ex);
  }).finally(() => {
     this.userLoaded = true;
};

假设我必须在角度2中做同样的事情

如何在角度2承诺中添加finally块,截至目前只有then & catch blocks角度2可用.如果不是最后那么在执行每个方法之后有没有办法添加清理代码,我在哪里编写代码来做最后的阻塞活动？