Правильний спосіб написання циклів для обіцянки.

Як правильно побудувати цикл, щоб переконатися, що наступний виклик обіцянки та ланцюжок logger.log (res) працює синхронно через ітерацію? (синій птах)

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

Я спробував наступним чином (метод від http://blog.victorquinn.com/javascript-promise-time-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');
}); 

Хоча це, здається, працює, але я не думаю, що це гарантує порядок виклику logger.log (res);

Будь-які пропозиції?

Я не думаю, що це гарантує порядок виклику logger.log (res);

Власне, це і є. Ця заява виконується перед resolveвикликом.

Будь-які пропозиції?

Багато. Найголовніше - це використовувати антипатрій створення - обіцяти - вручну - лише робити це

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

По-друге, цю whileфункцію можна було б значно спростити:

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

По-третє, я б не використовував whileцикл (зі змінною закриття), а forцикл:

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

Якщо ви дійсно хочете отримати загальну promiseWhen()функцію для цієї та інших цілей, то, безумовно, зробіть це, використовуючи спрощення Бергі. Однак через спосіб, який обіцяє роботу, передача зворотних дзвінків таким чином, як правило, непотрібна і змушує перестрибувати маленькі складні обручі.

Наскільки я можу сказати, ви намагаєтесь:

• асинхронно отримати ряд відомостей про користувача для колекції електронних адрес (принаймні, це єдиний сенс, який має сенс).
• зробити це шляхом побудови .then()ланцюга за допомогою рекурсії.
• підтримувати початковий порядок під час обробки повернених результатів.

Визначена таким чином, проблема є фактично тією, яку обговорювали у розділі "Колекція Kerfuffle" в Promise Anti- pattern , яка пропонує два простих рішення:

• паралельні асинхронні дзвінки з використанням Array.prototype.map()
• серійні асинхронні дзвінки з використанням Array.prototype.reduce().

Паралельний підхід (прямолінійно) дасть питання, якого ви намагаєтеся уникнути - про те, що порядок відповідей є невизначеним. Серійний підхід побудує необхідний .then()ланцюг - плоску - без рекурсії.

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

Телефонуйте так:

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

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

Як бачите, немає ніякої необхідності в потворному зовнішньому var countабо пов'язаній з ним conditionфункції. Межа (10 у запитанні) повністю визначається довжиною масиву arrayOfEmailAddys.

Ось як я це роблю зі стандартним об'єктом Promise.

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

Дано

• функція asyncFn
• масив елементів

вимагається

• обіцяють ланцюжок .then () в серії (по порядку)
• рідний es6

Рішення

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())

Існує новий спосіб вирішити це, і це за допомогою функції 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

Запропонована функція Бергі дуже хороша:

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

Я все ж хочу зробити крихітний додаток, яке має сенс при використанні обіцянок:

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

Таким чином цикл while може бути вбудований у ланцюжок обіцянок і вирішується за допомогою lastValue (також якщо дія () ніколи не виконується). Див. Приклад:

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

Я б зробив щось подібне:

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

таким чином, dataAll - це впорядкований масив усіх елементів для реєстрації. І робота журналу буде виконана, коли всі обіцянки виконані.

Використовуйте асинхронізацію та очікуйте (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);
});

Як щодо цього, який використовує BlueBird ?

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

Ось ще один метод (ES6 w / std Обіцяння). Використовує критерії виходу типів подання / підкреслення (return === false). Зауважте, що ви можете легко додати метод exitIf () в опціях для запуску в 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)
    })
};

Використовуючи стандартний об’єкт обіцянки та маючи обіцянку повернути результати.

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

Спочатку візьміть масив обіцянок (масив обіцянок), а після вирішіть ці масиви обіцянок за допомогою 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
}