Definiere leere Bluebird-Versprechen wie in Q

Mit Q kann ich definieren, ein neues Versprechen mit:

var queue = q();

Aber mit Bluebird, wenn ich tun:

var queue = new Promise();

Bekomme ich:

TypeError: the promise constructor requires a resolver function

Wie bekomme ich das gleiche Ergebnis hatte, dass ich mit Q?

Dies ist ein Ausschnitt von meinem code:

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 () {
   //...
});

InformationsquelleAutor der Frage Fez Vrasta | 2014-03-27

23
```
var resolver = Promise.defer();
setTimeout(function() {
    resolver.resolve(something); //Resolve the value
}, 5000);
return resolver.promise;
```
Diese Zeile ist ziemlich Häufig in der Dokumentation.

Bewusst sein, dass dies in der Regel ein anti-pattern zu verwenden. Aber wenn du weißt, was du tust, Promise.defer() ist ein Weg, um die Auflösung, die ist ähnlich wie Q in den Weg.

Es ist jedoch davon abgeraten, diese Methode verwenden. Bluebird hat auch veraltet.

Verwenden Sie stattdessen so:
```
return new Promise(function(resolve, reject) {
    //Your code
});
```
Finden Sie in der entsprechenden Dokumentation bits: Versprechen.defer() und neue Versprechen().

Nach der Aktualisierung Ihrer Frage, hier ist Ihr Problem: Sie sind das wiederverwenden die gleichen Versprechen zu lösen, mehrere Werte. Ein Versprechen kann nur gelöst werden, wenn. Es heißt, Sie haben zu verwenden Promise.defer() so oft, wie Sie verspricht.

Sagte, dass, nachdem ich mehr von deinem code, es scheint, Sie sind wirklich die Verwendung von anti-patterns. Ein Vorteil verspricht, ist die Fehlerbehandlung. Für Ihren Fall, würden Sie brauchen nur den folgenden code:
```
var gitControl = Promise.promisifyAll(Main.gitControl);
var promises = [];
promises.push(gitControl.gitAddAsync(fileObj.filename, updateIndex));
return promises;
```
Dies sollte genug, um Ihre Nutzung Fall. Es ist viel klarer, und es hat auch den Vorteil, wirklich Umgang mit dem Fehler richtig.

InformationsquelleAutor der Antwort Florian Margaine

Florian eine gute Antwort Für den Willen deiner ursprünglichen Frage, es gibt mehrere Möglichkeiten, um zu starten eine Kette mit Bluebird.

Einer der einfachsten ist der Aufruf Promise.resolve() auf nichts:

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

oder

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

Also können Sie tun:

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 () {
   //...
});

Obwohl, ich persönlich würde so etwas machen:

//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
    });

InformationsquelleAutor der Antwort Benjamin Gruenbaum

Stieß ich auf dieses, wie ich eine Methode, die holt eine Ressource auf dem internet und gibt den Inhalt zurück, aber ich will es zu behandeln, Verbindungs-timeouts, und wiederholen Sie bis zu X-mal mit Verzögerungen zwischen.

Als Bluebird.defer ist veraltet, ich habe diese, die funktioniert dieser trick:

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;
    });

InformationsquelleAutor der Antwort Kus

Finde ich ein Muster wie dieses nützlich für jede Art von Integrationstests.

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

InformationsquelleAutor der Antwort Sam B.

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.