javascript - new - Defina la promesa vacía de Bluebird como en Q

promise resolve

Question

Con QI puedo definir una nueva promesa con:

var queue = q();

Pero con Bluebird si lo hago:

var queue = new Promise();

Yo obtengo:

TypeError: the promise constructor requires a resolver function

¿Cómo puedo obtener el mismo resultado que tuve con Q?

Este es un fragmento de mi código:

var queue    = q()
    promises = [];
queue = queue.then(function () {
    return Main.gitControl.gitAdd(fileObj.filename, updateIndex);
});
// Here more promises are added to queue in the same way used above...
promises.push(queue);
return Promise.all(promises).then(function () {
   // ...
});

Answer 1

Encuentro que un patrón como este es útil para cualquier tipo de prueba de integración.

const responseResolver;

const response = new Promise(resolve => {
    responseResolver = resolve;
}).then(data => {
    console.log("data: ", data);
    return data;
});

// mock some method that returns a promise (e.g. waits for a response)
service.getIceCreams = () => response;

// do some assertions while the response is pending

responseResolver("cookie dough"); // will trigger .then: "data: cookie dough"

// do some assertions now that the response is completed

Answer 2

Florian proporcionó una buena respuesta Por el bien de su pregunta original, hay varias formas de comenzar una cadena con Bluebird.

Uno de los más simples es llamar a Promise.resolve() en nada:

var queue = Promise.resolve(); //resolve a promise with nothing or cast a value

o

Promise.try(function(...){
    return ...//chain here
});

Entonces puedes hacer:

var queue    = Promise.resolve()
    promises = [];
queue = queue.then(function () {
    return Main.gitControl.gitAdd(fileObj.filename, updateIndex);
});

// Here more promises are added to queue in the same way used above...
promises.push(queue);
return Promise.all(promises).then(function () {
   // ...
});

Aunque, personalmente, haría algo como:

//arr is your array of fileObj and updateIndex

Promise.map(arr,function(f){ return Main.gitControl.gitAdd(f.filename,f.updateIndex).
    then (function(result){
        //results here
    });

Answer 3

Me encontré con esto porque tenía un método que busca un recurso en Internet y devuelve el contenido, pero quiero que maneje los tiempos de espera de conexión y vuelva a intentar hasta X veces con retrasos entre.

Como Bluebird.defer está en desuso, utilicé esto que hace este truco:

const Promise = require(''bluebird'');

var fetch = function (options, promise) {
    var resolve, reject;
    if (promise) {
        resolve = promise.resolve;
        reject = promise.reject;
        promise = promise.promise;
    } else {
        promise = new Promise(function () {
            resolve = arguments[0];
            reject = arguments[1];
        });
    }
    var retry = {promise: promise, resolve: resolve, reject: reject};

    // Your logic here that you want to retry
    if (typeof options.x === ''undefined'') {
        reject(new Error(''X not defined''));
    } else if (options.x < 3) {
        options.x++;
        options.retryAttempt = (options.retryAttempt || 0) + 1;
        console.log(`Retrying in 1 second attempt ${options.retryAttempt}...`);
        setTimeout(() => {
            fetch(options, retry)
        }, 1000);
    } else {
        resolve(options.x);
    }

    return promise;
}

fetch({x:0})
    .then(res => {
        console.log(res);
    })
    .catch(err => {
        throw err;
    });

Answer 4

var resolver = Promise.defer();
setTimeout(function() {
    resolver.resolve(something); // Resolve the value
}, 5000);
return resolver.promise;

Esta línea se usa con bastante frecuencia en la documentation .

Tenga en cuenta que esto suele ser un anti-patrón para usar eso. Pero si sabes lo que estás haciendo, Promise.defer() es una forma de obtener el resolver que es similar al de Q.

Sin embargo, se desaconseja usar este método. Bluebird incluso lo ha desaprobado.

En cambio, debes usar de esta manera:

return new Promise(function(resolve, reject) {
    // Your code
});

Consulte los bits de documentación relevantes: Promise.defer() y nuevo Promise () .

Después de la actualización de su pregunta, este es su problema: está reutilizando la misma promesa para resolver varios valores. Una promesa solo puede resolverse una vez. Significa que tiene que usar Promise.defer() tantas veces como tenga promesas.

Dicho esto, después de ver más de tu código, parece que realmente estás usando antipatrones. Una ventaja de usar promesas es el manejo de errores. Para su caso, solo necesitaría el siguiente código:

var gitControl = Promise.promisifyAll(Main.gitControl);
var promises = [];
promises.push(gitControl.gitAddAsync(fileObj.filename, updateIndex));
return promises;

Esto debería ser suficiente para manejar su caso de uso. Es mucho más claro, y también tiene la ventaja de realmente manejar los errores correctamente.