Chaîne Angulaire $http appels correctement?

Promet vraiment aider avec le code de composition de prise d'appels asynchrones. En d'autres termes, ils vous permettent de composer votre code de manière similaire à la façon dont vous composez un synchrones série d'appels (avec l'utilisation de enchaînés .thens) et, comme si elle la synchronisation de code était dans un try/catch bloc (avec .catch).

Donc, imaginez que votre HTTP appels ont été blocage - la logique que vous avez ressemblerait donc:

var allowedAccess, data;
try {
  allowedAccess = $http.get(something);

  if (allowedAccess){
    try{
      var result = $http.get(somethingElse);
      data = {data: result};
    } catch (){
      data = {data: "n0pe"};
    }
  } else {
    data = {data: "n0pe"};
  }
} catch (){
  data = {data: "n0pe"};
}
return data;

Vous pouvez simplifier un peu:

var allowedAccess, result;
try {
  allowedAccess = $http.get(something);
  var result;
  if (allowedAccess) {
     result = $http.get(somethingElse);
  } else {
     throw;
  }
  data = {data: result};
} catch () {
   data = {data: "n0pe"};
}
return data;

Et qui pourrait se traduire à la version asynchrone de:

return $http
          .get(something)
          .then(function(allowedAccess){
             if (allowedAccess){
               return $http.get(somethingElse);
             } else {
               return $q.reject(); //this is the "throw;" from above
             }
          })
          .then(function(result){
             return {data: result};
          })
          .catch(function(){
             return {data: "n0pe"};
          })

Au moins, c'est le raisonnement que vous pourriez appliquer lors de la rédaction d'un code avec des branches et des appels asynchrones.

Je ne dis pas que la version que j'ai présenté est optimal ou court - il est, cependant, plus SEC à cause d'une simple erreur de manipulation. Mais juste de réaliser que lorsque vous ne .then(success, error) c'est équivalent à try/catch au cours de la précédente opération asynchrone - cela peut ou peut ne pas être nécessaire en fonction de votre situation spécifique.

OriginalL'auteur New Dev

$q, aide à réduire la pyramide des appels comme ceci:

async-call1.then(...
  aysnc-call2.then(...

Ce blog - http://chariotsolutions.com/blog/post/angularjs-corner-using-promises-q-handle-asynchronous-calls/ - offre un moyen propre de faire plusieurs requêtes HTTP. Avis le plus propre approche à l'aide de q$. Dans le cas où vous vous appuyant sur un seul point de terminaison HTTP à l'aide de votre méthode aurait été tout simplement parfait. Je dirais, est-ce que vous avez est très bien aussi; $q pourrait permettre une plus grande souplesse dans l'avenir.

Le blog décrit un service tout en utilisant $q et le code est plus propre.

service('asyncService', function($http, $q) {
  return {
    loadDataFromUrls: function(urls) {
      var deferred = $q.defer();
      var urlCalls = [];
      angular.forEach(urls, function(url) {
        urlCalls.push($http.get(url.url));
      });
      //they may, in fact, all be done, but this
      //executes the callbacks in then, once they are
      //completely finished.
      $q.all(urlCalls)
      .then(...

Je suis un débutant avec des promesses aussi, afin de prendre cela avec un grain de sel.

OriginalL'auteur zedfoxus