Richtiger Weg, um Loops für Versprechen zu schreiben.

Wie kann eine Schleife korrekt erstellt werden, um sicherzustellen, dass der folgende Versprechensaufruf und die verkettete logger.log (res) synchron durch die Iteration ausgeführt werden? (Drossel)

db.getUser(email).then(function(res) { logger.log(res); }); // this is a promise

Ich habe den folgenden Weg versucht (Methode von http://blog.victorquinn.com/javascript-promise-while-loop )

var Promise = require('bluebird');

var promiseWhile = function(condition, action) {
    var resolver = Promise.defer();

    var loop = function() {
        if (!condition()) return resolver.resolve();
        return Promise.cast(action())
            .then(loop)
            .catch(resolver.reject);
    };

    process.nextTick(loop);

    return resolver.promise;
});

var count = 0;
promiseWhile(function() {
    return count < 10;
}, function() {
    return new Promise(function(resolve, reject) {
        db.getUser(email)
          .then(function(res) { 
              logger.log(res); 
              count++;
              resolve();
          });
    }); 
}).then(function() {
    console.log('all done');
}); 

Es scheint zwar zu funktionieren, aber ich glaube nicht, dass es die Reihenfolge des Aufrufs von logger.log (res) garantiert ;

Irgendwelche Vorschläge?

Ich glaube nicht, dass dies die Reihenfolge des Aufrufs von logger.log (res) garantiert.

Eigentlich schon. Diese Anweisung wird vor dem resolveAufruf ausgeführt.

Irgendwelche Vorschläge?

Viele. Das Wichtigste ist, dass Sie das Antipattern "Versprechen versprechen" manuell verwenden - tun Sie es einfach

promiseWhile(…, function() {
    return db.getUser(email)
             .then(function(res) { 
                 logger.log(res); 
                 count++;
             });
})…

Zweitens whilekönnte diese Funktion stark vereinfacht werden:

var promiseWhile = Promise.method(function(condition, action) {
    if (!condition()) return;
    return action().then(promiseWhile.bind(null, condition, action));
});

Drittens würde ich keine whileSchleife (mit einer Abschlussvariablen) verwenden, sondern eine forSchleife:

var promiseFor = Promise.method(function(condition, action, value) {
    if (!condition(value)) return value;
    return action(value).then(promiseFor.bind(null, condition, action));
});

promiseFor(function(count) {
    return count < 10;
}, function(count) {
    return db.getUser(email)
             .then(function(res) { 
                 logger.log(res); 
                 return ++count;
             });
}, 0).then(console.log.bind(console, 'all done'));

Wenn Sie wirklich eine allgemeine promiseWhen()Funktion für diesen und andere Zwecke wünschen , dann tun Sie dies auf jeden Fall mit Bergis Vereinfachungen. Aufgrund der Art und Weise, wie Versprechen funktionieren, ist das Übergeben von Rückrufen auf diese Weise im Allgemeinen nicht erforderlich und zwingt Sie, durch komplexe kleine Reifen zu springen.

Soweit ich das beurteilen kann, versuchen Sie:

• asynchrones Abrufen einer Reihe von Benutzerdetails für eine Sammlung von E-Mail-Adressen (zumindest ist dies das einzige sinnvolle Szenario).
• Dazu wird eine .then()Kette durch Rekursion aufgebaut.
• um die ursprüngliche Bestellung bei der Bearbeitung der zurückgegebenen Ergebnisse beizubehalten.

Das so definierte Problem ist tatsächlich das unter "The Collection Kerfuffle" in Promise Anti-Patterns diskutierte , das zwei einfache Lösungen bietet:

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

Der parallele Ansatz führt (direkt) zu dem Problem, das Sie vermeiden möchten - dass die Reihenfolge der Antworten ungewiss ist. Der serielle Ansatz erstellt die erforderliche .then()Kette - flach - ohne 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 an:

//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, ist die hässliche äußere Variable countoder die damit verbundene conditionFunktion nicht erforderlich . Die Grenze (von 10 in der Frage) wird vollständig durch die Länge des Arrays bestimmt arrayOfEmailAddys.

So mache ich es mit dem Standard-Promise-Objekt.

// Given async function sayHi
function sayHi() {
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log('Hi');
      resolve();
    }, 3000);
  });
}

// And an array of async functions to loop through
const asyncArray = [sayHi, sayHi, sayHi];

// We create the start of a promise chain
let chain = Promise.resolve();

// And append each function in the array to the promise chain
for (const func of asyncArray) {
  chain = chain.then(func);
}

// Output:
// Hi
// Hi (After 3 seconds)
// Hi (After 3 more seconds)

Gegeben

• asyncFn-Funktion
• Reihe von Elementen

Erforderlich

• verspreche Verkettung .then () ist in Reihe (in Reihenfolge)
• 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())

Es gibt einen neuen Weg, dies zu lösen, und zwar mithilfe von async / await.

async function myFunction() {
  while(/* my condition */) {
    const res = await db.getUser(email);
    logger.log(res);
  }
}

myFunction().then(() => {
  /* do other stuff */
})

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function https://ponyfoo.com/articles/understanding-javascript-async-await

Bergis vorgeschlagene Funktion ist wirklich nett:

var promiseWhile = Promise.method(function(condition, action) {
      if (!condition()) return;
    return action().then(promiseWhile.bind(null, condition, action));
});

Trotzdem möchte ich eine winzige Ergänzung machen, die Sinn macht, wenn ich Versprechen verwende:

var promiseWhile = Promise.method(function(condition, action, lastValue) {
  if (!condition()) return lastValue;
  return action().then(promiseWhile.bind(null, condition, action));
});

Auf diese Weise kann die while-Schleife in eine Versprechenskette eingebettet werden und mit lastValue aufgelöst werden (auch wenn die action () nie ausgeführt wird). Siehe Beispiel:

var count = 10;
util.promiseWhile(
  function condition() {
    return count > 0;
  },
  function action() {
    return new Promise(function(resolve, reject) {
      count = count - 1;
      resolve(count)
    })
  },
  count)

Ich würde so etwas machen:

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

Auf diese Weise ist dataAll ein geordnetes Array aller zu protokollierenden Elemente. Der Protokollvorgang wird ausgeführt, wenn alle Versprechen erfüllt sind.

Verwenden Sie asynchron und warten Sie (es6):

function taskAsync(paramets){
 return new Promise((reslove,reject)=>{
 //your logic after reslove(respoce) or reject(error)
})
}

async function fName(){
let arry=['list of items'];
  for(var i=0;i<arry.length;i++){
   let result=await(taskAsync('parameters'));
}

}

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

Wie wäre es mit BlueBird ?

function fetchUserDetails(arr) {
    return Promise.each(arr, function(email) {
        return db.getUser(email).done(function(res) {
            logger.log(res);
        });
    });
}

Hier ist eine andere Methode (ES6 mit Standardversprechen). Verwendet Exit-Kriterien vom Typ lodash / underscore (return === false). Beachten Sie, dass Sie in Optionen, die in doOne () ausgeführt werden sollen, problemlos eine exitIf () -Methode hinzufügen können.

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

Wenn Sie das Standardversprechenobjekt verwenden und das Versprechen haben, werden die Ergebnisse zurückgegeben.

function promiseMap (data, f) {
  const reducer = (promise, x) =>
    promise.then(acc => f(x).then(y => acc.push(y) && acc))
  return data.reduce(reducer, Promise.resolve([]))
}

var emails = []

function getUser(email) {
  return db.getUser(email)
}

promiseMap(emails, getUser).then(emails => {
  console.log(emails)
})

Nehmen Sie zuerst ein Versprechen-Array (Versprechen-Array) und lösen Sie dieses Versprechen-Array anschließend mit auf Promise.all(promisearray).

var arry=['raju','ram','abdul','kruthika'];

var promiseArry=[];
for(var i=0;i<arry.length;i++) {
  promiseArry.push(dbFechFun(arry[i]));
}

Promise.all(promiseArry)
  .then((result) => {
    console.log(result);
  })
  .catch((error) => {
     console.log(error);
  });

function dbFetchFun(name) {
  // we need to return a  promise
  return db.find({name:name}); // any db operation we can write hear
}