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

return value from promise

Question

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.

Answer 1

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

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

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

En su segundo ejemplo, devuelve una promesa que se resuelve inmediatamente con el valor "bbb" , por lo que "bbb" se pasa al siguiente controlador then() . (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.

Answer 2

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

A) Cuando x es 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) Cuando x es una Promesa que ya está liquidada (ya no está pendiente):

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

C) Cuando x es una promesa pendiente:

1. return x devolverá una Promesa pendiente, y luego se evaluará en el siguiente.

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

Answer 3

La regla es que, si la función que está en el controlador 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 cláusula será la cláusula de la promesa la función regresó , por lo tanto, en este caso, el primer ejemplo cae a través de la secuencia normal de las thens e imprime los valores como uno podría esperar, en el segundo ejemplo, el objeto de promesa que se devuelve cuando haces Promise.resolve("bbb") es entonces el que se invoca cuando se encadena (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 x es un thenable, intenta hacer que la promesa adopte el estado de x , bajo el supuesto de que x se comporta al menos algo como una promesa . De lo contrario, cumple la promesa con el valor x .

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

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

si x es una promesa, adopta su estado [3.4]

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

Answer 4

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

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

• Llamar a Promise.resolve (en su caso angular eso es $q.when )
• Llamando al constructor de la promesa y resolviendo en su resolutor. En su caso, eso es new $q .
• Devolver un valor de una devolució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 en general sea más fácil. Cada vez que se produce una resolución de promesa, se produce una resolución que crea consistencia general.