Quelle est la différence entre retourner une valeur ou Promise.resolve à partir de là ()

Quelle est la différence entre:

new Promise(function(res, rej) {
    res("aaa");
  })
  .then(function(result) {
    return "bbb";
  })
  .then(function(result) {
    console.log(result);
  });

et ça:

new Promise(function(res, rej) {
    res("aaa");
  })
  .then(function(result) {
    return Promise.resolve("bbb");
  })
  .then(function(result) {
    console.log(result);
  });

Je demande car j'obtiens un comportement différent Utilisation du service Angular et $ http avec le chaînage .then (). Un peu trop de code, donc d'abord l'exemple ci-dessus.

La règle est, si la fonction qui se trouve dans le thengestionnaire renvoie une valeur, la promesse se résout / rejette avec cette valeur, et si la fonction renvoie une promesse, ce qui se passe, la thenclause suivante sera la thenclause de la promesse que la fonction a renvoyée , donc, dans ce cas, le premier exemple passe par la séquence normale de thenset imprime les valeurs comme on pourrait s'y attendre, dans le deuxième exemple, l'objet de promesse qui est renvoyé lorsque vous le faites Promise.resolve("bbb")est alors celui thenqui est invoqué lors du chaînage (à toutes fins utiles). La façon dont cela fonctionne est décrite ci-dessous plus en détail.

Citant des promesses / A + spec:

La procédure de résolution de promesse est une opération abstraite prenant en entrée une promesse et une valeur que nous désignons [[Resolve]](promise, x). Si xest un élément exploitable, il tente de faire adopter à lax promesse l'état de , sous l'hypothèse que x se comporte au moins un peu comme une promesse . Sinon, il remplit sa promesse avec la valeur x.

Ce traitement des éléments exploitables permet aux implémentations de promesses d'interopérer, tant qu'elles exposent une méthode conforme à Promises / A +. Il permet également aux implémentations Promises / A + d '«assimiler» les implémentations non conformes avec des méthodes raisonnables.

La chose clé à noter ici est cette ligne:

si xc'est une promesse, adoptez son état [3.4]

lien: https://promisesaplus.com/#point-49

En termes simples, à l'intérieur d'une thenfonction de gestionnaire:

A) Quand xest une valeur (nombre, chaîne, etc.):

1. return x est équivalent à return Promise.resolve(x)
2. throw x est équivalent à return Promise.reject(x)

B) Quand xune promesse est-elle déjà réglée (plus en attente):

1. return xest équivalent à return Promise.resolve(x), si la Promesse a déjà été résolue.
2. return xest équivalent à return Promise.reject(x), si la promesse a déjà été rejetée.

C) Quand xune promesse est-elle en attente:

1. return xrenverra une promesse en attente, et elle sera évaluée lors de la suivante then.

En savoir plus sur ce sujet dans les documents Promise.prototype.then () .

Vos deux exemples devraient se comporter à peu près de la même manière.

Une valeur renvoyée à l'intérieur d'un then()gestionnaire devient la valeur de résolution de la promesse retournée à partir de cela then(). Si la valeur renvoyée à l'intérieur de la .then est une promesse, la promesse retournée par then()"adoptera l'état" de cette promesse et résoudra / rejetera tout comme la promesse retournée.

Dans votre premier exemple, vous revenez "bbb"dans le premier then()gestionnaire, donc "bbb"est passé dans le then()gestionnaire suivant .

Dans votre deuxième exemple, vous renvoyez une promesse qui est immédiatement résolue avec la valeur "bbb"et "bbb"est donc transmise au then()gestionnaire suivant . (L' Promise.resolve()ici est étranger).

Le résultat est le même.

Si vous pouvez nous montrer un exemple qui présente en fait un comportement différent, nous pouvons vous expliquer pourquoi cela se produit.

Vous avez déjà une bonne réponse formelle. J'ai pensé que je devrais en ajouter un court.

Les choses suivantes sont identiques aux promesses / promesses A + :

• Appel Promise.resolve(dans votre cas angulaire c'est $q.when)
• Appel du constructeur de promesses et résolution dans son résolveur. Dans votre cas, c'est new $q.
• Renvoyer une valeur à partir d'un thenrappel.
• Appelez Promise.all sur un tableau avec une valeur, puis extrayez cette valeur.

Ainsi, les éléments suivants sont tous identiques pour une promesse ou une valeur simple X:

Promise.resolve(x);
new Promise(function(resolve, reject){ resolve(x); });
Promise.resolve().then(function(){ return x; });
Promise.all([x]).then(function(arr){ return arr[0]; });

Et ce n'est pas surprenant, la spécification des promesses est basée sur la procédure de résolution des promesses qui permet une interaction facile entre les bibliothèques (comme $ q et les promesses natives) et vous facilite la vie dans l'ensemble. Chaque fois qu'une résolution de promesse peut se produire, une résolution se produit, créant une cohérence globale.

La seule différence est que vous créez une promesse inutile lorsque vous le faites return Promise.resolve("bbb"). Le renvoi d'une promesse d'un onFulfilled()gestionnaire démarre la résolution de la promesse . Voilà comment fonctionne le chaînage des promesses .