約束のためにループを書く正しい方法。
次の約束呼び出しと連鎖logger.log（res）が繰り返し実行されることを保証するためにループを正しく構築する方法？ （青い鳥）
db.getUser(email).then(function(res) { logger.log(res); }); // this is a promise
私は次の方法を試してみました（ 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');
});
うまくいくようですが、logger.log（res）を呼び出す順序を保証するものではないと思いますが、
助言がありますか？
私はそれがlogger.log（res）を呼び出す順番を保証するとは思いません。
実はそうです。そのステートメントはresolve呼び出しの前に実行されます。
助言がありますか？
たくさん。最も重要なのは、 create-promise-manualアンチパターン の使用です。
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()関数が欲しいならば、それから絶対にBergiの単純化を使ってそうしてください。しかし、約束どおりに機能するので、この方法でコールバックを渡すことは一般に不要であり、複雑な小さなフープを飛び越えることを強いられます。
私ができる限り、あなたが試みていると言うことができます：
- 電子メールアドレスのコレクションの一連のユーザー詳細を非同期的に取得する（少なくとも、これが唯一の意味があるシナリオです）。
- 再帰によって
.then()チェーンを構築することによってそうするために。 - 返された結果を処理するときに元の順序を維持します。
このように定義されると、問題は実際には Promise Anti-patterns の "The Collection Kerfuffle"で説明されているもので、2つの簡単な解決策を提供します。
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_functionhttps://ponyfoo.com/articles/understanding-javascript-非同期待ち
私はこのようなものを作りたいと思います：
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はログに記録するすべての要素の順序付き配列です。そして、約束がすべて完了したときにログ操作が実行されます。
Bergiが提案している機能は本当にいいです。
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ループをpromiseチェーンに埋め込むことができ、lastValueで解決できます（action（）が実行されない場合も同様です）。例を参照してください。
var count = 10;
util.promiseWhile(
function condition() {
return count > 0;
},
function action() {
return new Promise(function(resolve, reject) {
count = count - 1;
resolve(count)
})
},
count)
非同期を使用して待つ（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'));
}
}
標準のpromiseオブジェクトを使用して、promiseに結果を返させる。
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の配列（promise配列）を取り、Promise.all(promisearray)を使用してこれらのpromise配列を解決します。
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
}
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 Promise）。 lodash/underscoreタイプの終了基準を使用します（return === false）。 doOne（）で実行するためのオプションにexitIf（）メソッドを簡単に追加できることに注意してください。
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)
})
};