Qual è la differenza tra il valore di ritorno o Promise.resolve da then ()

Qual è la differenza tra:

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

e questo:

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

Sto chiedendo come sto ottenendo un comportamento diverso Usando il servizio Angular e $ http con il concatenamento .then (). Un po 'troppo di codice, quindi prima l'esempio sopra.

La regola è, se la funzione che si trova nel thengestore restituisce un valore, la promessa si risolve / rifiuta con quel valore e se la funzione restituisce una promessa, ciò che accade è, la thenclausola successiva sarà la thenclausola della promessa restituita dalla funzione , quindi, in questo caso, il primo esempio cade attraverso la normale sequenza di thense stampa i valori come ci si potrebbe aspettare, nel secondo esempio, l'oggetto promessa che viene restituito quando lo si fa Promise.resolve("bbb")è quello thenche viene invocato durante il concatenamento (a tutti gli effetti). Il modo in cui funziona effettivamente è descritto di seguito in modo più dettagliato.

Citando dalle promesse / A + specifiche:

La procedura di risoluzione delle promesse è un'operazione astratta che prende come input una promessa e un valore, che denotiamo come [[Resolve]](promise, x). Se xè possibile, cerca di far sì che la promessa adotti lo stato dix , supponendo che x si comporti almeno in qualche modo come una promessa . Altrimenti, mantiene la promessa con il valore x.

Questo trattamento dei prodotti in questione consente alle implementazioni promettenti di interagire, purché espongano un metodo conforme a Promises / A +. Inoltre, consente alle implementazioni Promises / A + di "assimilare" le implementazioni non conformi con metodi ragionevoli.

La cosa fondamentale da notare qui è questa riga:

se xè una promessa, adotta il suo stato [3.4]

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

In termini semplici, all'interno di a then funzione del gestore:

A) Quando xè un valore (numero, stringa, ecc.):

1. return x è equivalente a return Promise.resolve(x)
2. throw x è equivalente a return Promise.reject(x)

B) Quando xè una promessa già stabilita (non più in sospeso):

1. return xè equivalente a return Promise.resolve(x), se la Promessa era già stata risolta.
2. return xè equivalente a return Promise.reject(x), se la Promessa è stata già respinta.

C) Quando xè una promessa in sospeso:

1. return xrestituirà una Promessa in sospeso e verrà valutata sulla successiva then.

Maggiori informazioni su questo argomento nei documenti Promise.prototype.then () .

Entrambi i tuoi esempi dovrebbero comportarsi più o meno allo stesso modo.

Un valore restituito all'interno di un then()gestore diventa il valore di risoluzione della promessa restituita da quello then(). Se il valore restituito all'interno di .then è una promessa, la promessa restituita dathen() "adotterà lo stato" di quella promessa e si risolverà / rifiuterà proprio come fa la promessa restituita.

Nel tuo primo esempio, ritorni "bbb"nel primo then()gestore, quindi "bbb"viene passato al then()gestore successivo .

Nel tuo secondo esempio, restituisci una promessa che viene immediatamente risolta con il valore "bbb", quindi "bbb"viene passata al then()gestore successivo . (Il Promise.resolve()qui è estraneo).

Il risultato è lo stesso.

Se puoi mostrarci un esempio che mostra effettivamente comportamenti diversi, possiamo dirti perché sta accadendo.

Hai già una buona risposta formale. Ho pensato di aggiungerne uno breve.

Le seguenti cose sono identiche alle promesse / A + promesse:

• Chiamata Promise.resolve(nel tuo caso angolare $q.when)
• Chiamare il costruttore della promessa e risolverlo nel suo risolutore. Nel tuo caso è quello new $q.
• Restituzione di un valore da a then richiamata.
• Chiamata Promise.all su un array con un valore e quindi estrarre quel valore.

Quindi i seguenti sono tutti identici per una promessa o un semplice valore 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]; });

E non è una sorpresa, le specifiche delle promesse si basano sulla procedura di risoluzione delle promesse che consente una facile interazione tra le librerie (come $ q e promesse native) e semplifica la vita. Ogni volta che potrebbe verificarsi una risoluzione promettente, si verifica una risoluzione che crea coerenza generale.

L'unica differenza è che stai creando una promessa non necessaria quando lo fai return Promise.resolve("bbb"). Restituire una promessa da un onFulfilled()gestore dà il via alla risoluzione della promessa . Ecco come funziona il concatenamento promettente .