Bluebird Promise serial-iteration, und beschließen, modifizierte array?

Habe ich das Versprechen, dass eine neue Item Dokument, wenn es nicht in der db und speichert Sie dann in eine zuvor erstellte Collection - Dokument..

Der Sammlung Dokument ist die erste Zeichenkette in ein array, und alle nachfolgenden index im array bedeutet: ein oder mehrere Element docs.

Versprechen.jeder "Löst die ursprüngliche array wird nicht geändert" und so ist die Letzte return innerhalb der Promise.each ist das rendering der Objekte, sondern auch die nachfolgenden .then produziert das original-array..

Hier ist die Verheißung (gekürzt, für bessere Lesbarkeit):

globalVar = true;
collectionId = "";
var itemSeries = Promise.each(items, function(element) {
    if (globalVar == true) {
        return Models.Collection.findOneAsync({
            "name": element
        })
        .then(function(collection) {
            //promise chain similar to the following else..
            //set the collectionId var to an _id
        });
    } else {
        return Models.Items.findOneAsync({
            "name": element
        })
        .then(function(item) {
            if (item == null) {
                return Models.Labels.findOneAsync({
                    "title": element
                })
                .then(function(label) {
                    var newItem = new Models.Items({
                        name: element,
                        label: label._id
                    });
                    return newItem.saveAsync();
                }).then(function() {
                    return Models.Items.findOneAsync({
                        "name": element
                    });
                }).then(function(item) {
                    item.collection = collectionId;
                    return item.saveAsync();
                }).then(function() {
                    return Models.Items.findOneAsync({
                        "name": element
                    });
                }).then(function(item) {
                    allItems.push(item);
                    console.log("allItems: [ ");
                    console.log(allItems);
                    return allItems;
                });
            }
        });
    }
}).then(function(allItems) {
    console.log("allItems: [ ");
    console.log(allItems);
    return allItems;
});

Und hier ist der Letzte der console.log innerhalb der Verheißung.jeder:

allItems: [ 
[ { _id: 54eec5f2b9fb280000286d52,
    name: 'one',
    label: 54eec5f2b9fb280000286d51,
    collection: 54eec5f2b9fb280000286d50,
    __v: 0 },
  { _id: 54eec5f2b9fb280000286d54,
    name: 'two',
    label: 54eec5f2b9fb280000286d53,
    collection: 54eec5f2b9fb280000286d50,
    __v: 0 } ]

Und dann nach der anschließenden .then(function(allItems) { hier ist die Letzte console.log:

allItems: [ 
[ 'collectionName', 'one', 'two' ]

Auch, die variable itemSeries dass = Promise.each später macht undefined in ein Versprechen.beitreten?

InformationsquelleAutor Stacks | 2015-02-26
  1. 24

    Den .each Funktion nicht den Wert ändern, der ist übergeben durch die Kette:

    Ich vereinfachter code, der als Eingabe nehme ich an:

    var items = ['one','two'];

    Für Ihren code:

    Promise.each(items, function(element) {
    return element+'.';
    //return Promise.resolve(element+'.');
})
.then(function(allItems) {
    console.dir(allItems);
});

    Wird das Ergebnis noch ['one','two'] weil diese behoben sind Werte der array -items. Der zurückgegebene Wert innerhalb des einzelnen keinen Einfluss auf den Inhalt des übergebenen Wertes an die verkettete then.

    Den .map Funktion auf der anderen Seite wird dieser Effekt haben:

    Promise.map(items, function(element) {
    return element+'.';
    //return Promise.resolve(element+'.');
})
.then(function(allItems) {
    console.dir(allItems);
});

    Hier die return Wert wird verwendet, um ein neues array zurück, das wird dann weitergegeben an das then. Hier das Ergebnis wäre ['one.','two.'].

    Den beiden allItems erscheinen in deinem code sind verschiedene Objekte.

    BEARBEITEN
    Für Seriell iteration, die mit der Zuordnung würde ich schreiben, eine Helfer-Funktion, wie diese:

     function mapSeries(things, fn) {
     var results = [];
     return Promise.each(things, function(value, index, length) {
         var ret = fn(value, index, length);
         results.push(ret);
         return ret;
     }).thenReturn(results).all();
 }

    Quelle: Implementieren Sie Versprechen.Serie

    • Okay, wie kann die allItems Wert zurückgegeben werden? .jeder ist notwendig, weil die Sequenz erforderlich ist..
    • Hinzugefügt ein edit zu meinem Kommentar.
    • fwiw .jeder arbeitet wie .mapSeries in 3.0 seit der Rückkehr der bestehende array nicht sinnvoll
    • oh das ist gut zu wissen. Ich bin mir ziemlich sicher das relais auf dieses Verhalten irgendwo -.-
    • Genial. Vielen Dank für die mapSeries
    • Statt zu schreiben eine mapSeries Funktion, bluebirds Versprechen.reduzieren können auch den trick tun. github.com/petkaantonov/bluebird/issues/70

    InformationsquelleAutor t.niese
  2. 1

    Bluebird nun nativ implementiert eine mapSeries finden Sie http://bluebirdjs.com/docs/api/promise.mapseries.html

    Es sieht auch wie Promise.each noch gibt das ursprüngliche array leider in v3.x.x.

    InformationsquelleAutor Adam Reis
Schreibe einen Kommentar