promesas - promise javascript

Obtenga la primera promesa cumplida

Question

Si tengo dos promesas A y B, de las cuales solo una tendrá éxito, ¿cómo puedo obtener la que cumpla satisfactoriamente? Estoy buscando algo similar a Promise.race , pero que devolverá solo la primera promesa que cumple. Estoy usando promesas de ES6.

Answer 1

Invierte la polaridad de las promesas, y luego puedes usar Promise.all , porque rechaza en la primera promesa rechazada, que después de la inversión corresponde a la primera promesa cumplida:

const invert  = p  => new Promise((res, rej) => p.then(rej, res));
const firstOf = ps => invert(Promise.all(ps.map(invert)));

// Utility routines used only in testing.
const wait    = ms => new Promise(res => setTimeout(() => res(ms), ms));
const fail    = f  => Promise.reject(f);
const log     = p  => p.then(v => console.log("pass", v), v => console.log("fail", v));

// Test.
log(firstOf([wait(1000), wait(500) ]));
log(firstOf([wait(1000), fail("f1")]));
log(firstOf([fail("f1"), fail("f2")]));

Esto devolverá el valor de la primera promesa cumplida, o si todos rechazan, una serie de razones de rechazo.

Answer 2

Si quiere la primera promesa que se resuelve satisfactoriamente y desea ignorar cualquier rechazo que venga antes, entonces puede usar algo como esto:

// returns the result from the first promise that resolves
// or rejects if all the promises reject - then return array of rejected errors
function firstPromiseResolve(array) {
    return new Promise(function(resolve, reject) {
        if (!array || !array.length) {
            return reject(new Error("array passed to firstPromiseResolve() cannot be empty"));
        }
        var errors = new Array(array.length);
        var errorCntr = 0;
        array.forEach(function (p, index) {
            // when a promise resolves
            Promise.resolve(p).then(function(val) {
                // only first one to call resolve will actually do anything
                resolve(val);
            }, function(err) {
                errors[index] = err;
                ++errorCntr;
                // if all promises have rejected, then reject
                if (errorCntr === array.length) {
                    reject(errors);
                }
            });
        });
    });
}

No veo cómo puede usar Promise.race() para esto porque simplemente informa la primera promesa de finalización y, si esa primera promesa se rechaza, informará un rechazo. Por lo tanto, no está haciendo lo que usted pidió en su pregunta, que es informar la primera promesa que se resuelve (incluso si algunos rechazos terminaron antes).

Para su información, la biblioteca de promesa de Bluebird tiene tanto Promise.some() como Promise.any() que pueden manejar este caso por usted.

Answer 3

 //example 1
    var promise_A = new Promise(function(resolve, reject) {
        // выполнить что-то, возможно, асинхронно…
        setTimeout(function(){

            return  resolve(10);
            //return reject(new Error(''ошибка''))
        },10000)
    });

    var promise_B = new Promise(function(resolve, reject) {
        // выполнить что-то, возможно, асинхронно…

        setTimeout(function(){
            return  resolve(100);
        },2000)
    });


/*
 //[100,10]
 Promise.all([
  promise_A,promise_B
 ]).then(function(results){
  console.log(results)
 });
*/

 //100
 Promise.race([
  promise_A,promise_B
 ]).then(function(results){
  console.log(results)
 });