Richtiger Weg, Schleifen für Versprechen zu schreiben.

Wenn Sie wirklich wollen, eine Allgemeine promiseWhen() Funktion für diese und andere Zwecke, dann mit allen Mitteln tun, mit Bergi ist Vereinfachungen. Jedoch, wegen der Art, verspricht Arbeit, vorbei Rückrufe auf diese Weise ist in der Regel unnötig und zwingt Sie, um zu springen über komplexe wenig Reifen.

Soweit ich sagen kann, Sie versuchen :

• asynchron zu Holen eine Reihe von Benutzer-details für eine Sammlung von E-Mail-Adressen (zumindest ist das das einzige Szenario, das Sinn macht).
• zu tun, so durch den Bau einer .then() Kette über Rekursion.
• zu pflegen die ursprüngliche Reihenfolge bei der Behandlung der zurückgegebenen Ergebnisse.

Definiert also, das problem ist eigentlich das ein, diskutiert Sie unter "Die Sammlung Kerfuffle" in Versprechen Anti-patternsdie zwei einfache Lösungen :

• parallele asynchrone Aufrufe mit Array.prototype.map()
• serielle asynchrone Aufrufe mit Array.prototype.reduce().

Den parallelen Ansatz (einfach) das Problem, dass Sie versuchen zu vermeiden, dass die Reihenfolge der Antworten ist ungewiss. Der serielle Ansatz erstellen Sie die benötigte .then() Kette - flat - keine Rekursion.

function fetchUserDetails(arr) {
    return arr.reduce(function(promise, email) {
        return promise.then(function() {
            return db.getUser(email).done(function(res) {
                logger.log(res);
            });
        });
    }, Promise.resolve());
}

Rufen Sie wie folgt vor :

//Compose here, by whatever means, an array of email addresses.
var arrayOfEmailAddys = [...];

fetchUserDetails(arrayOfEmailAddys).then(function() {
    console.log('all done');
});

Wie Sie sehen können, gibt es keine Notwendigkeit für das hässliche äußere var count oder es ist verbunden condition Funktion. Die Grenze (von 10 in der Frage) ist bestimmt nicht ganz von der Länge des Arrays arrayOfEmailAddys.

InformationsquelleAutor der Antwort Roamer-1888

Gegeben

• asyncFn Funktion
• array der Elemente

Erforderlich

• Versprechen Verkettung .dann()'s in Reihe (in order)
• native es6

Lösung

let asyncFn = (item) => {
  return new Promise((resolve, reject) => {
    setTimeout( () => {console.log(item); resolve(true)}, 1000 )
  })
}

//asyncFn('a')
//.then(()=>{return async('b')})
//.then(()=>{return async('c')})
//.then(()=>{return async('d')})

let a = ['a','b','c','d']

a.reduce((previous, current, index, array) => {
  return previous                                    //initiates the promise chain
  .then(()=>{return asyncFn(array[index])})      //adds .then() promise for each item
}, Promise.resolve())

InformationsquelleAutor der Antwort kamran

Ich würde so etwas wie dieses:

var request = []
while(count<10){
   request.push(db.getUser(email).then(function(res) { return res; }));
   count++
};

Promise.all(request).then((dataAll)=>{
  for (var i = 0; i < dataAll.length; i++) {

      logger.log(dataAll[i]); 
  }  
});

in dieser Weise, dataAll ist eine sortierte array von element zu melden. Und log-Vorgang durchzuführen, wenn alle Versprechungen werden gemacht.

InformationsquelleAutor der Antwort Claudio M

function promiseLoop(promiseFunc, paramsGetter, conditionChecker, eachFunc, delay) {
    function callNext() {
        return promiseFunc.apply(null, paramsGetter())
            .then(eachFunc)
    }

    function loop(promise, fn) {
        if (delay) {
            return new Promise(function(resolve) {
                setTimeout(function() {
                    resolve();
                }, delay);
            })
                .then(function() {
                    return promise
                        .then(fn)
                        .then(function(condition) {
                            if (!condition) {
                                return true;
                            }
                            return loop(callNext(), fn)
                        })
                });
        }
        return promise
            .then(fn)
            .then(function(condition) {
                if (!condition) {
                    return true;
                }
                return loop(callNext(), fn)
            })
    }

    return loop(callNext(), conditionChecker);
}


function makeRequest(param) {
    return new Promise(function(resolve, reject) {
        var req = https.request(function(res) {
            var data = '';
            res.on('data', function (chunk) {
                data += chunk;
            });
            res.on('end', function () {
                resolve(data);
            });
        });
        req.on('error', function(e) {
            reject(e);
        });
        req.write(param);
        req.end();
    })
}

function getSomething() {
    var param = 0;

    var limit = 10;

    var results = [];

    function paramGetter() {
        return [param];
    }
    function conditionChecker() {
        return param <= limit;
    }
    function callback(result) {
        results.push(result);
        param++;
    }

    return promiseLoop(makeRequest, paramGetter, conditionChecker, callback)
        .then(function() {
            return results;
        });
}

getSomething().then(function(res) {
    console.log('results', res);
}).catch(function(err) {
    console.log('some error along the way', err);
});

InformationsquelleAutor der Antwort Tengiz

Hier ist eine andere Methode (ES6 w/std Versprechen). Verwendet lodash, unterstreichen, geben Sie exit Kriterien (return === false). Beachten Sie, dass Sie könnte leicht fügen Sie eine exitIf () - Methode in den Optionen zum ausführen in doOne().

const whilePromise = (fnReturningPromise,options = {}) => { 
    //loop until fnReturningPromise() === false
    //options.delay - setTimeout ms (set to 0 for 1 tick to make non-blocking)
    return new Promise((resolve,reject) => {
        const doOne = () => {
            fnReturningPromise()
            .then((...args) => {
                if (args.length && args[0] === false) {
                    resolve(...args);
                } else {
                    iterate();
                }
            })
        };
        const iterate = () => {
            if (options.delay !== undefined) {
                setTimeout(doOne,options.delay);
            } else {
                doOne();
            }
        }
        Promise.resolve()
        .then(iterate)
        .catch(reject)
    })
};

InformationsquelleAutor der Antwort Gary Skiba