javascript - funciones - promesas typescript

¿Por qué esta cadena de promesas se resuelve inmediatamente?

Question

¿Puede alguien explicarme por qué la promesa resultante ( d ) del código siguiente se resuelve de inmediato?

//promises that are never resolved nor rejected
var a = new Promise(function(r,re){});
var b = new Promise(function(r,re){});
var c = new Promise(function(r,re){});
var d = [a, b, c].reduce(function (previousPromise, promise) {
return previousPromise.then(promise);
}, Promise.resolve());

Estoy creando una serie de promesas que están pendientes para siempre, por lo que la promesa resultante también debería estar pendiente para siempre, ya que espera a que finalicen todas las promesas posteriores ( como se presenta aquí ). He estado usando promesas desde hace un tiempo, pero claramente me falta algo aquí.

Answer 1

var d = [a, b, c].reduce(function (previousPromise, promise) {
return previousPromise.then(promise);
}, Promise.resolve());

Se ha resuelto tu estado inicial de d promesa, tu set es como Promise.resolve (). Consulte la documentación de reducir https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce

Answer 2

then no toma una Promise como entrada, toma 2 funciones, 1 para cumplimiento y 1 para rechazo.

La razón por la que d se resuelve se debe al hecho de que al invocar .then con un valor no recuperable (incluso un número literal - 1, o undefined ), la función onFulfilled se reemplaza por "Identity", que simplemente se reajusta con lo que sea el valor se resolvió en el paso anterior. Ver PerformPromiseThen

Pruebe de esta manera:

//promises that are never resolved nor rejected
var a = function() { return new Promise(function(r,re){}); };
var b = function() { return new Promise(function(r,re){}); };
var c = function() { return new Promise(function(r,re){}); };
// or simply, a = b = c after setting the function for c
var d = [a, b, c].reduce(function (previousPromise, fn) {
return previousPromise.then(fn, /* not passing a rejection handler... */);
}, Promise.resolve());

O alternativamente...

//promises that are never resolved nor rejected
var a = new Promise(function(r,re){});
var b = new Promise(function(r,re){});
var c = new Promise(function(r,re){});
var d = [a, b, c].reduce(function (previousPromise, promise) {
return previousPromise.then(function() {return promise;});
}, Promise.resolve());

Y como está utilizando promesas y ES6, podría ser más conciso:

let a = new Promise(() => {});
let b = new Promise(() => {});
let c = new Promise(() => {});
let d = [a, b, c].reduce((previousPromise, promise) =>
previousPromise.then(() => promise),
Promise.resolve());