¿Cuál es la diferencia entre el valor de retorno o Promise.resolve desde entonces ()

Cuál es la diferencia entre:

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

y esto:

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

Pregunto ya que obtengo un comportamiento diferente Uso del servicio Angular y $ http con el encadenamiento .then (). Demasiado código, por lo tanto, primero el ejemplo anterior.

La regla es, si la función que está en el thencontrolador devuelve un valor, la promesa se resuelve / rechaza con ese valor, y si la función devuelve una promesa, lo que sucede es que la siguiente thencláusula será la thencláusula de la promesa que la función devolvió , por lo tanto, en este caso, el primer ejemplo cae a través de la secuencia normal de los thensvalores e imprime como se podría esperar, en el segundo ejemplo, el objeto de promesa que se devuelve cuando lo hace Promise.resolve("bbb")es el thenque se invoca al encadenar (para todos los efectos). La forma en que realmente funciona se describe a continuación con más detalle.

Citando de las promesas / especificaciones A +:

El procedimiento de resolución de promesas es una operación abstracta que toma como entrada una promesa y un valor, que denotamos como [[Resolve]](promise, x). Si xes posible, intenta hacer que la promesa adopte el estado dex , bajo el supuesto de que x se comporta al menos como una promesa . De lo contrario, cumple la promesa con el valor x.

Este tratamiento de los elementos nobles permite que las implementaciones de promesas interoperen, siempre que expongan un método compatible con Promesas / A +. También permite que las implementaciones Promises / A + "asimilen" implementaciones no conformes con métodos razonables.

La clave para notar aquí es esta línea:

si xes una promesa, adopte su estado [3.4]

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

En términos simples, dentro de una thenfunción de controlador:

A) Cuando xes un valor (número, cadena, etc.):

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

B) Cuándo xes una promesa que ya está liquidada (ya no está pendiente):

1. return xes equivalente a return Promise.resolve(x), si la promesa ya se resolvió.
2. return xes equivalente a return Promise.reject(x), si la promesa ya fue rechazada.

C) Cuando xhay una promesa pendiente:

1. return xdevolverá una Promesa pendiente y se evaluará en el siguiente then.

Lea más sobre este tema en los documentos Promise.prototype.then () .

Ambos ejemplos deberían comportarse más o menos igual.

Un valor devuelto dentro de un then()controlador se convierte en el valor de resolución de la promesa devuelta de eso then(). Si el valor devuelto dentro del .then es una promesa, la promesa devuelta por then()"adoptará el estado" de esa promesa y se resolverá / rechazará tal como lo hace la promesa devuelta.

En su primer ejemplo, regresa "bbb"en el primer then()controlador, por lo que "bbb"se pasa al siguiente then()controlador.

En su segundo ejemplo, devuelve una promesa que se resuelve de inmediato con el valor "bbb", por lo que "bbb"se pasa al siguiente then()controlador. (El Promise.resolve()aquí es extraño).

El resultado es el mismo.

Si puede mostrarnos un ejemplo que en realidad exhibe un comportamiento diferente, podemos decirle por qué sucede eso.

Ya tienes una buena respuesta formal. Pensé que debería agregar uno corto.

Las siguientes cosas son idénticas a las promesas / promesas A + :

• Llamando Promise.resolve(en su caso angular, eso es $q.when)
• Llamando al constructor de la promesa y resolviendo en su resolutor. En tu caso eso es new $q.
• Devolver un valor de una thendevolución de llamada.
• Llamar a Promise.all en una matriz con un valor y luego extraer ese valor.

Por lo tanto, los siguientes son idénticos para una promesa o un valor 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]; });

Y no es sorprendente, la especificación de promesas se basa en el Procedimiento de resolución de promesas que permite una fácil interoperación entre bibliotecas (como $ q y promesas nativas) y hace que su vida sea más fácil en general. Cada vez que se produce una resolución prometedora, se produce una resolución que crea coherencia general.

La única diferencia es que estás creando una promesa innecesaria cuando lo haces return Promise.resolve("bbb"). Devolver una promesa de un onFulfilled()controlador inicia la resolución de la promesa . Así es como funciona el encadenamiento de promesas .