Angular HttpPromise: différence entre les méthodes `success` / ʻerror` et les arguments de` then`

Selon la documentation AngularJS , les appels pour $httprenvoyer ce qui suit:

Renvoie un objet de promesse avec la méthode standard then et deux méthodes spécifiques http: succès et erreur . La méthode then prend deux arguments un succès et un rappel d' erreur qui sera appelé avec un objet de réponse. Les méthodes de succès et d' erreur prennent un seul argument - une fonction qui sera appelée lorsque la demande réussit ou échoue respectivement. Les arguments passés dans ces fonctions sont une représentation déstructurée de l'objet de réponse transmis à la méthode then.

Mis à part le fait que l' responseobjet est déstructuré dans un cas, je ne comprends pas la différence entre

• les rappels de succès / erreur passés pour être passés comme arguments de promise.then
• les callbacks passés en arguments pour les méthodes promise.success/ promise.errorde la promesse

Y a-t-il? Quel est l'intérêt de ces deux façons différentes de passer des rappels apparemment identiques?

NB Cette réponse est factuellement incorrecte; comme indiqué par un commentaire ci-dessous, success () renvoie la promesse d'origine. Je ne changerai pas; et laissez OP pour modifier.

La principale différence entre les 2 est que l' .then()appel renvoie une promesse (résolue avec une valeur renvoyée par un rappel) alors qu'il .success()s'agit d'une manière plus traditionnelle d'enregistrer des rappels et ne renvoie pas de promesse.

Les rappels basés sur les promesses ( .then()) facilitent l'enchaînement des promesses (faire un appel, interpréter les résultats puis faire un autre appel, interpréter les résultats, faire encore un autre appel, etc.).

La .success()méthode est une méthode simplifiée et pratique lorsque vous n'avez pas besoin de chaîner un appel ni de travailler avec l'API de promesse (par exemple, dans le routage).

En bref:

• .then() - pleine puissance de l'API promise mais légèrement plus verbeuse
• .success() - ne retourne pas de promesse mais offre une syntaxe légèrement plus pratique

Il y a déjà de bonnes réponses ici. Mais cela vaut la peine de souligner la différence de parallélisme offerte:

• success() renvoie la promesse originale
• then() renvoie une nouvelle promesse

La différence réside dans then()les opérations séquentielles, car chaque appel renvoie une nouvelle promesse.

$http.get(/*...*/).
  then(function seqFunc1(response){/*...*/}).
  then(function seqFunc2(response){/*...*/})

1. $http.get()
2. seqFunc1()
3. seqFunc2()

success() conduit des opérations parallèles, puisque les gestionnaires sont enchaînés sur la même promesse.

$http(/*...*/).
  success(function parFunc1(data){/*...*/}).
  success(function parFunc2(data){/*...*/})

1. $http.get()
2. parFunc1(), parFunc2()en parallèle

Quelques exemples de code pour une simple requête GET. Peut-être que cela aide à comprendre la différence. Utilisation then:

$http.get('/someURL').then(function(response) {
    var data = response.data,
        status = response.status,
        header = response.header,
        config = response.config;
    // success handler
}, function(response) {
    var data = response.data,
        status = response.status,
        header = response.header,
        config = response.config;
    // error handler
});

Utilisation de success/ error:

$http.get('/someURL').success(function(data, status, header, config) {
    // success handler
}).error(function(data, status, header, config) {
    // error handler
});

.then () est chaînable et attendra la résolution de .then () précédente.

.success () et .error () peuvent être enchaînés, mais ils se déclencheront tous en même temps (donc pas grand chose à cela)

.success () et .error () sont juste bien pour les appels simples (fabricants faciles):

$http.post('/getUser').success(function(user){ 
   ... 
})

donc vous n'avez pas à taper ceci:

$http.post('getUser').then(function(response){
  var user = response.data;
})

Mais généralement, je gère toutes les erreurs avec .catch ():

$http.get(...)
    .then(function(response){ 
      // successHandler
      // do some stuff
      return $http.get('/somethingelse') // get more data
    })
    .then(anotherSuccessHandler)
    .catch(errorHandler)

Si vous avez besoin de prendre en charge <= IE8, écrivez votre .catch () et .finally () comme ceci (méthodes réservées dans IE):

    .then(successHandler)
    ['catch'](errorHandler)

Exemples de travail:

Voici quelque chose que j'ai écrit dans un format plus codé pour rafraîchir ma mémoire sur la façon dont tout se joue avec les erreurs de gestion, etc.

http://jsfiddle.net/nalberg/v95tekz2/

Juste pour terminer, voici un exemple de code indiquant les différences:

succès \ erreur:

$http.get('/someURL')
.success(function(data, status, header, config) {
    // success handler
})
.error(function(data, status, header, config) {
    // error handler
});

puis:

$http.get('/someURL')
.then(function(response) {
    // success handler
}, function(response) {
    // error handler
})
.then(function(response) {
    // success handler
}, function(response) {
    // error handler
})
.then(function(response) {
    // success handler
}, function(response) {
    // error handler
}).

Avis officiel: le succès et l'erreur sont obsolètes, veuillez utiliser la méthode standard then à la place.

Avis de dépréciation: Les méthodes de promesse héritées de $ http réussies et erreurs sont devenues obsolètes. Utilisez plutôt la méthode standard alors. Si $ httpProvider.useLegacyPromiseExtensions est défini sur false, ces méthodes génèrent une erreur $ http / legacy.

lien: https://code.angularjs.org/1.5.7/docs/api/ng/service/$http

capture d'écran: voir la capture d'écran