Cách chính xác để viết vòng cho lời hứa.

Cách xây dựng chính xác một vòng lặp để đảm bảo cuộc gọi hứa hẹn sau đây và logger.log (res) chạy đồng bộ thông qua việc lặp lại? (chim xanh)

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

Tôi đã thử cách sau (phương pháp từ http://blog.victorquinn.com/javascript-promise-fter-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');
}); 

Mặc dù nó có vẻ hoạt động, nhưng tôi không nghĩ nó đảm bảo thứ tự gọi logger.log (res);

Bất kỳ đề xuất?

Tôi không nghĩ rằng nó đảm bảo thứ tự gọi logger.log (res);

Trên thực tế, nó làm. Câu lệnh đó được thực thi trước resolvecuộc gọi.

Bất kỳ đề xuất?

Rất nhiều. Điều quan trọng nhất là việc bạn sử dụng antipotype tạo lời hứa bằng tay - chỉ cần làm

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

Thứ hai, whilechức năng đó có thể được đơn giản hóa rất nhiều:

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

Thứ ba, tôi sẽ không sử dụng whilevòng lặp (với biến đóng) mà là forvòng lặp:

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

Nếu bạn thực sự muốn một vị tướng promiseWhen() chức năng cho mục đích này và các mục đích khác, thì bằng mọi cách hãy làm như vậy, sử dụng đơn giản hóa của Bergi. Tuy nhiên, vì cách thức hứa hẹn hoạt động, việc chuyển các cuộc gọi lại theo cách này thường không cần thiết và buộc bạn phải nhảy qua những vòng nhỏ phức tạp.

Theo như tôi có thể nói bạn đang cố gắng:

• để tìm nạp không đồng bộ một loạt các chi tiết người dùng cho một bộ sưu tập địa chỉ email (ít nhất, đó là kịch bản duy nhất có ý nghĩa).
• để làm như vậy bằng cách xây dựng một .then()chuỗi thông qua đệ quy.
• để duy trì thứ tự ban đầu khi xử lý các kết quả trả về.

Do đó, được xác định, vấn đề thực sự là vấn đề được thảo luận trong phần "Bộ sưu tập Kerfuffle" trong các mẫu chống Promise , cung cấp hai giải pháp đơn giản:

• các cuộc gọi không đồng bộ song song sử dụng Array.prototype.map()
• cuộc gọi không đồng bộ nối tiếp sử dụng Array.prototype.reduce().

Cách tiếp cận song song sẽ (đơn giản) đưa ra vấn đề mà bạn đang cố gắng tránh - rằng thứ tự của các câu trả lời là không chắc chắn. Cách tiếp cận nối tiếp sẽ xây dựng .then()chuỗi yêu cầu - phẳng - không đệ quy.

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

Gọi như sau:

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

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

Như bạn có thể thấy, không cần var bên ngoài xấu xí counthay conditionchức năng liên quan của nó . Giới hạn (của 10 trong câu hỏi) được xác định hoàn toàn bởi độ dài của mảng arrayOfEmailAddys.

Đây là cách tôi làm với đối tượng Promise tiêu chuẩn.

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

Được

• chức năng asyncFn
• mảng vật phẩm

Cần thiết

• hứa hẹn xâu chuỗi .then () trong chuỗi (theo thứ tự)
• es6 bản địa

Giải pháp

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

Có một cách mới để giải quyết vấn đề này và đó là sử dụng 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_feft https://ponyfoo.com/articles/under Hiểu-javascript-async-randit

Chức năng gợi ý của Bergi's thực sự rất hay:

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

Tôi vẫn muốn thực hiện một bổ sung nhỏ, có ý nghĩa khi sử dụng lời hứa:

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

Bằng cách này, vòng lặp while có thể được nhúng vào chuỗi hứa hẹn và giải quyết bằng lastValue (cũng như nếu hành động () không bao giờ chạy). Xem ví dụ:

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

Tôi sẽ làm một cái gì đó như thế này:

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

theo cách này, dataAll là một mảng được sắp xếp của tất cả các phần tử để đăng nhập. Và hoạt động đăng nhập sẽ thực hiện khi tất cả các lời hứa được thực hiện.

Sử dụng async và chờ đợi (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);
});

Làm thế nào về điều này bằng cách sử dụng BlueBird ?

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

Đây là một phương pháp khác (ES6 w / std Promise). Sử dụng tiêu chí thoát kiểu lodash / gạch dưới (return === false). Lưu ý rằng bạn có thể dễ dàng thêm phương thức exit If () trong các tùy chọn để chạy trong 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)
    })
};

Sử dụng đối tượng lời hứa tiêu chuẩn và có lời hứa sẽ trả về kết quả.

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

Đầu tiên hãy lấy mảng lời hứa (mảng hứa) và sau khi giải quyết các mảng lời hứa này bằng cách sử dụng 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
}