Node.jsで非同期関数の長いネストを回避する方法
DBのデータを表示するページを作成したいので、DBからそのデータを取得する関数をいくつか作成しました。私はNode.jsの初心者なので、理解している限りでは、すべてを1つのページ（HTTP応答）で使用する場合は、すべてをネストする必要があります。
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
var html = "<h1>Demo page</h1>";
getSomeDate(client, function(someData) {
html += "<p>"+ someData +"</p>";
getSomeOtherDate(client, function(someOtherData) {
html += "<p>"+ someOtherData +"</p>";
getMoreData(client, function(moreData) {
html += "<p>"+ moreData +"</p>";
res.write(html);
res.end();
});
});
});
そのような関数が多数ある場合、-ネストが問題になります。
これを回避する方法はありますか？複数の非同期関数を組み合わせる方法に関係していると思いますが、これは基本的なことのようです。
興味深い観察。 JavaScriptでは、通常、インラインの匿名コールバック関数を名前付き関数変数に置き換えることができます。
以下：
http.createServer(function (req, res) {
// inline callback function ...
getSomeData(client, function (someData) {
// another inline callback function ...
getMoreData(client, function(moreData) {
// one more inline callback function ...
});
});
// etc ...
});
次のように書き換えることができます。
var moreDataParser = function (moreData) {
// date parsing logic
};
var someDataParser = function (someData) {
// some data parsing logic
getMoreData(client, moreDataParser);
};
var createServerCallback = function (req, res) {
// create server logic
getSomeData(client, someDataParser);
// etc ...
};
http.createServer(createServerCallback);
ただし、他の場所でコールバックロジックに再利用する予定がない限り、多くの場合、例のようにインラインの匿名関数を読む方がはるかに簡単です。また、すべてのコールバックの名前を見つける必要がなくなります。
さらに、以下のコメントで @ pst に記載されているように、内部関数内でクロージャー変数にアクセスしている場合、上記は簡単な翻訳ではないことに注意してください。このような場合、インライン匿名関数を使用することがさらに望ましいです。
ケイ、これらのモジュールのいずれかを使用します。
これは次のようになります：
dbGet('userIdOf:bobvance', function(userId) {
dbSet('user:' + userId + ':email', '[email protected]', function() {
dbSet('user:' + userId + ':firstName', 'Bob', function() {
dbSet('user:' + userId + ':lastName', 'Vance', function() {
okWeAreDone();
});
});
});
});
これに：
flow.exec(
function() {
dbGet('userIdOf:bobvance', this);
},function(userId) {
dbSet('user:' + userId + ':email', '[email protected]', this.MULTI());
dbSet('user:' + userId + ':firstName', 'Bob', this.MULTI());
dbSet('user:' + userId + ':lastName', 'Vance', this.MULTI());
},function() {
okWeAreDone()
}
);
ネストされた関数やモジュールではなく、配列でこのトリックを使用できます。
目に優しい。
var fs = require("fs");
var chain = [
function() {
console.log("step1");
fs.stat("f1.js",chain.shift());
},
function(err, stats) {
console.log("step2");
fs.stat("f2.js",chain.shift());
},
function(err, stats) {
console.log("step3");
fs.stat("f2.js",chain.shift());
},
function(err, stats) {
console.log("step4");
fs.stat("f2.js",chain.shift());
},
function(err, stats) {
console.log("step5");
fs.stat("f2.js",chain.shift());
},
function(err, stats) {
console.log("done");
},
];
chain.shift()();
並列プロセスまたは並列プロセスチェーンのイディオムを拡張できます。
var fs = require("fs");
var fork1 = 2, fork2 = 2, chain = [
function() {
console.log("step1");
fs.stat("f1.js",chain.shift());
},
function(err, stats) {
console.log("step2");
var next = chain.shift();
fs.stat("f2a.js",next);
fs.stat("f2b.js",next);
},
function(err, stats) {
if ( --fork1 )
return;
console.log("step3");
var next = chain.shift();
var chain1 = [
function() {
console.log("step4aa");
fs.stat("f1.js",chain1.shift());
},
function(err, stats) {
console.log("step4ab");
fs.stat("f1ab.js",next);
},
];
chain1.shift()();
var chain2 = [
function() {
console.log("step4ba");
fs.stat("f1.js",chain2.shift());
},
function(err, stats) {
console.log("step4bb");
fs.stat("f1ab.js",next);
},
];
chain2.shift()();
},
function(err, stats) {
if ( --fork2 )
return;
console.log("done");
},
];
chain.shift()();
ほとんどの場合、ダニエル・ヴァッサロに同意します。複雑で深くネストされた関数を個別の名前付き関数に分割できる場合は、通常は良い考えです。単一の関数内で実行することが理にかなっている場合は、利用可能な多くのnode.js非同期ライブラリの1つを使用できます。人々はこれに取り組むためのさまざまな方法を考え出しているので、node.jsモジュールのページを見て、あなたの考えを見てください。
async.js というモジュールを自分で作成しました。これを使用して、上記の例を次のように更新できます。
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
async.series({
someData: async.apply(getSomeDate, client),
someOtherData: async.apply(getSomeOtherDate, client),
moreData: async.apply(getMoreData, client)
},
function (err, results) {
var html = "<h1>Demo page</h1>";
html += "<p>" + results.someData + "</p>";
html += "<p>" + results.someOtherData + "</p>";
html += "<p>" + results.moreData + "</p>";
res.write(html);
res.end();
});
});
このアプローチの利点の1つは、 'series'関数を 'parallel'に変更することで、コードをすばやく変更してデータを並列にフェッチできることです。さらに、async.jsはブラウザー内でも機能するため、トリッキーな非同期コードが発生した場合は、node.jsと同じ方法を使用できます。
それが役に立つことを願っています！
私は async.js がこの目的のためにたくさん好きです。
この問題は、ウォーターフォールコマンドによって解決されます。
ウォーターフォール（タスク、[コールバック]）
関数の配列を連続して実行し、それぞれが結果を配列内の次の配列に渡します。ただし、いずれかの関数がエラーをコールバックに渡すと、次の関数は実行されず、メインコールバックがすぐにエラーで呼び出されます。
引数
タスク-実行する関数の配列。各関数にはコールバック（err、result1、result2、...）が渡され、完了時に呼び出す必要があります。最初の引数はエラー（nullの場合もあります）であり、それ以降の引数は次のタスクに引数として渡されます。 callback（err、[results]）-すべての機能が完了すると実行されるオプションのコールバック。これには、最後のタスクのコールバックの結果が渡されます。
例
async.waterfall([
function(callback){
callback(null, 'one', 'two');
},
function(arg1, arg2, callback){
callback(null, 'three');
},
function(arg1, callback){
// arg1 now equals 'three'
callback(null, 'done');
}
], function (err, result) {
// result now equals 'done'
});
Req、res変数については、async.waterfall呼び出し全体を囲むfunction（req、res）{}と同じスコープ内で共有されます。
それだけでなく、非同期は非常にクリーンです。つまり、次のような多くのケースを変更するということです。
function(o,cb){
function2(o,function(err, resp){
cb(err,resp);
})
}
最初に：
function(o,cb){
function2(o,cb);
}
次にこれに：
function2(o,cb);
次にこれに：
async.waterfall([function2,function3,function4],optionalcb)
また、非同期用に準備された多くの事前作成関数をutil.jsから非常に高速に呼び出すことができます。あなたがしたいことをつなぐだけで、o、cbが普遍的に処理されることを確認してください。これにより、コーディングプロセス全体が大幅に高速化されます。
必要なのは、ちょっとした構文糖です。これをチェックしてください：
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
var html = ["<h1>Demo page</h1>"];
var pushHTML = html.Push.bind(html);
Queue.Push( getSomeData.partial(client, pushHTML) );
Queue.Push( getSomeOtherData.partial(client, pushHTML) );
Queue.Push( getMoreData.partial(client, pushHTML) );
Queue.Push( function() {
res.write(html.join(''));
res.end();
});
Queue.execute();
});
かなりneatではありませんか？ htmlが配列になったことにお気づきかもしれません。これは、文字列が不変であるためです。そのため、より大きな文字列を破棄するよりも、配列に出力をバッファリングする方が良いでしょう。もう1つの理由は、bindを使用した別のNice構文が原因です。
例のQueueは実際には単なる例であり、partialとともに次のように実装できます。
// Functional programming for the rescue
Function.prototype.partial = function() {
var fun = this,
preArgs = Array.prototype.slice.call(arguments);
return function() {
fun.apply(null, preArgs.concat.apply(preArgs, arguments));
};
};
Queue = [];
Queue.execute = function () {
if (Queue.length) {
Queue.shift()(Queue.execute);
}
};
恋をしている Async.js 見つけて以来。長いネストを回避するために使用できる async.series 関数があります。
ドキュメント：-
series（tasks、[callback]）
関数の配列を連続して実行します。各関数は、前の関数が完了すると実行されます。 [...]
引数
tasks-実行する関数の配列。各関数には、完了時に呼び出す必要があるコールバックが渡されます。 callback(err, [results])-すべての機能が完了したら実行するオプションのコールバック。この関数は、配列で使用されるコールバックに渡されるすべての引数の配列を取得します。
サンプルコードに適用する方法は次のとおりです。
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
var html = "<h1>Demo page</h1>";
async.series([
function (callback) {
getSomeData(client, function (someData) {
html += "<p>"+ someData +"</p>";
callback();
});
},
function (callback) {
getSomeOtherData(client, function (someOtherData) {
html += "<p>"+ someOtherData +"</p>";
callback();
});
},
funciton (callback) {
getMoreData(client, function (moreData) {
html += "<p>"+ moreData +"</p>";
callback();
});
}
], function () {
res.write(html);
res.end();
});
});
私が見た中で最も単純な構文糖は、ノードプロミスです。
npm install node-promise || git clone https://github.com/kriszyp/node-promise
これを使用して、非同期メソッドを次のように連鎖できます。
firstMethod().then(secondMethod).then(thirdMethod);
それぞれの戻り値は、次の引数として使用できます。
そこで行ったことは、非同期パターンを取得し、順番に呼び出される3つの関数に適用します。各関数は、前の関数が完了するまで待機してから開始します。つまり、同期にしました。非同期プログラミングのポイントは、複数の機能をすべて同時に実行でき、それぞれの完了を待つ必要がないことです。
getSomeDate（）がgetMoreSomeOtherDate（）に何も提供せず、getMoreData（）に何も提供しない場合、jsが許可するように非同期で呼び出したり、相互依存（非同期ではない）でそれらをa単一機能？
フローを制御するためにネストを使用する必要はありません。たとえば、3つすべてが完了してから応答を送信する共通の関数を呼び出すことにより、各関数を終了させます。
コールバックhellは、クロージャを使用した純粋なjavascriptで簡単に回避できます。以下のソリューションでは、すべてのコールバックが関数（エラー、データ）署名に従うことを前提としています。
http.createServer(function (req, res) {
var modeNext, onNext;
// closure variable to keep track of next-callback-state
modeNext = 0;
// next-callback-handler
onNext = function (error, data) {
if (error) {
modeNext = Infinity;
} else {
modeNext += 1;
}
switch (modeNext) {
case 0:
res.writeHead(200, {'Content-Type': 'text/html'});
var html = "<h1>Demo page</h1>";
getSomeDate(client, onNext);
break;
// handle someData
case 1:
html += "<p>"+ data +"</p>";
getSomeOtherDate(client, onNext);
break;
// handle someOtherData
case 2:
html += "<p>"+ data +"</p>";
getMoreData(client, onNext);
break;
// handle moreData
case 3:
html += "<p>"+ data +"</p>";
res.write(html);
res.end();
break;
// general catch-all error-handler
default:
res.statusCode = 500;
res.end(error.message + '\n' + error.stack);
}
};
onNext();
});
これができると仮定します：
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
var html = "<h1>Demo page</h1>";
chain([
function (next) {
getSomeDate(client, next);
},
function (next, someData) {
html += "<p>"+ someData +"</p>";
getSomeOtherDate(client, next);
},
function (next, someOtherData) {
html += "<p>"+ someOtherData +"</p>";
getMoreData(client, next);
},
function (next, moreData) {
html += "<p>"+ moreData +"</p>";
res.write(html);
res.end();
}
]);
});
Chain（）を実装するだけで、各関数が次の関数に部分的に適用され、すぐに最初の関数のみが呼び出されます。
function chain(fs) {
var f = function () {};
for (var i = fs.length - 1; i >= 0; i--) {
f = fs[i].partial(f);
}
f();
}
私は最近wait.forと呼ばれるより単純な抽象化を作成し、同期モード（ファイバーに基づいて）で非同期関数を呼び出しました。それは初期段階ですが、動作します。次の場所にあります。
https://github.com/luciotato/waitfor
wait.forを使用すると、標準のnodejs非同期関数を同期関数であるかのように呼び出すことができます。
wait.forを使用すると、コードは次のようになります。
var http=require('http');
var wait=require('wait.for');
http.createServer(function(req, res) {
wait.launchFiber(handleRequest,req, res); //run in a Fiber, keep node spinning
}).listen(8080);
//in a fiber
function handleRequest(req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
var html = "<h1>Demo page</h1>";
var someData = wait.for(getSomeDate,client);
html += "<p>"+ someData +"</p>";
var someOtherData = wait.for(getSomeOtherDate,client);
html += "<p>"+ someOtherData +"</p>";
var moreData = wait.for(getMoreData,client);
html += "<p>"+ moreData +"</p>";
res.write(html);
res.end();
};
...またはより冗長にしたい場合（およびエラーキャッチを追加する場合）
//in a fiber
function handleRequest(req, res) {
try {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write(
"<h1>Demo page</h1>"
+ "<p>"+ wait.for(getSomeDate,client) +"</p>"
+ "<p>"+ wait.for(getSomeOtherDate,client) +"</p>"
+ "<p>"+ wait.for(getMoreData,client) +"</p>"
);
res.end();
}
catch(err) {
res.end('error '+e.message);
}
};
すべての場合において、getSomeDate、getSomeOtherDateおよびgetMoreDataは標準の非同期である必要があります最後のパラメータを持つ関数function callback（err、data）
次のように：
function getMoreData(client, callback){
db.execute('select moredata from thedata where client_id=?',[client.id],
,function(err,data){
if (err) callback(err);
callback (null,data);
});
}
この問題を解決するために、目に見えないようにJSを前処理するnodent（ https://npmjs.org/package/nodent ）を作成しました。サンプルコードは（非同期、実際-ドキュメントを読む）になります。
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
var html = "<h1>Demo page</h1>";
someData <<= getSomeDate(client) ;
html += "<p>"+ someData +"</p>";
someOtherData <<= getSomeOtherDate(client) ;
html += "<p>"+ someOtherData +"</p>";
moreData <<= getMoreData(client) ;
html += "<p>"+ moreData +"</p>";
res.write(html);
res.end();
});
明らかに、他の多くのソリューションがありますが、前処理にはランタイムオーバーヘッドがほとんどまたはまったくないという利点があり、ソースマップサポートのおかげでデバッグも簡単です。
これにはasync.jsが適しています。例でasync.jsの必要性と使用法を説明するこの非常に有用な記事に出会いました： http://www.sebastianseilund.com/nodejs-async-in-practice
Task.jsはこれを提供します：
spawn(function*() {
try {
var [foo, bar] = yield join(read("foo.json"),
read("bar.json")).timeout(1000);
render(foo);
render(bar);
} catch (e) {
console.log("read failed: " + e);
}
});
これの代わりに：
var foo, bar;
var tid = setTimeout(function() { failure(new Error("timed out")) }, 1000);
var xhr1 = makeXHR("foo.json",
function(txt) { foo = txt; success() },
function(err) { failure() });
var xhr2 = makeXHR("bar.json",
function(txt) { bar = txt; success() },
function(e) { failure(e) });
function success() {
if (typeof foo === "string" && typeof bar === "string") {
cancelTimeout(tid);
xhr1 = xhr2 = null;
render(foo);
render(bar);
}
}
function failure(e) {
xhr1 && xhr1.abort();
xhr1 = null;
xhr2 && xhr2.abort();
xhr2 = null;
console.log("read failed: " + e);
}
C＃のようなasyncawaitは、これを行う別の方法です
https://github.com/yortus/asyncawait
async(function(){
var foo = await(bar());
var foo2 = await(bar2());
var foo3 = await(bar2());
}
jazz.jsをご検討ください https://github.com/Javanile/Jazz.js/wiki/Script-showcase
const jj = require（ 'jazz.js'）; //超互換スタック jj.script（ a => ProcessTaskOneCallbackAtEnd（a）、 b => ProcessTaskTwoCallbackAtEnd（b）、 c => ProcessTaskThreeCallbackAtEnd（c）、 d => ProcessTaskFourCallbackAtEnd（d）、 e => ProcessTaskFiveCallbackAtEnd（e）、 ）;
wire を使用すると、コードは次のようになります。
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
var l = new Wire();
getSomeDate(client, l.branch('someData'));
getSomeOtherDate(client, l.branch('someOtherData'));
getMoreData(client, l.branch('moreData'));
l.success(function(r) {
res.write("<h1>Demo page</h1>"+
"<p>"+ r['someData'] +"</p>"+
"<p>"+ r['someOtherData'] +"</p>"+
"<p>"+ r['moreData'] +"</p>");
res.end();
});
});
他の人が応答した後、あなたはあなたの問題がローカル変数であると述べました。これを行う簡単な方法は、これらのローカル変数を含む1つの外部関数を記述し、名前付き内部関数の束を使用し、名前でアクセスすることです。この方法では、連鎖する必要のある関数の数に関係なく、2つの深さだけをネストできます。
ネスティングでmysql Node.jsモジュールを使用しようとする私の初心者の試みは次のとおりです。
function with_connection(sql, bindings, cb) {
pool.getConnection(function(err, conn) {
if (err) {
console.log("Error in with_connection (getConnection): " + JSON.stringify(err));
cb(true);
return;
}
conn.query(sql, bindings, function(err, results) {
if (err) {
console.log("Error in with_connection (query): " + JSON.stringify(err));
cb(true);
return;
}
console.log("with_connection results: " + JSON.stringify(results));
cb(false, results);
});
});
}
以下は、名前付き内部関数を使用した書き換えです。外部関数with_connectionは、ローカル変数のホルダーとしても使用できます。 （ここでは、sql、bindings、cbのパラメーターがありますが、これらは同様の方法で動作しますが、with_connectionで追加のローカル変数を定義できます。）
function with_connection(sql, bindings, cb) {
function getConnectionCb(err, conn) {
if (err) {
console.log("Error in with_connection/getConnectionCb: " + JSON.stringify(err));
cb(true);
return;
}
conn.query(sql, bindings, queryCb);
}
function queryCb(err, results) {
if (err) {
console.log("Error in with_connection/queryCb: " + JSON.stringify(err));
cb(true);
return;
}
cb(false, results);
}
pool.getConnection(getConnectionCb);
}
インスタンス変数を使用してオブジェクトを作成し、これらのインスタンス変数をローカル変数の代わりとして使用することはおそらく可能であると考えていました。しかし、ネストされた関数とローカル変数を使用した上記のアプローチは、より簡単で理解しやすいことがわかりました。オブジェクト指向を解くには少し時間がかかりそうです:-)
オブジェクトとインスタンス変数を使用した以前のバージョンです。
function DbConnection(sql, bindings, cb) {
this.sql = sql;
this.bindings = bindings;
this.cb = cb;
}
DbConnection.prototype.getConnection = function(err, conn) {
var self = this;
if (err) {
console.log("Error in DbConnection.getConnection: " + JSON.stringify(err));
this.cb(true);
return;
}
conn.query(this.sql, this.bindings, function(err, results) { self.query(err, results); });
}
DbConnection.prototype.query = function(err, results) {
var self = this;
if (err) {
console.log("Error in DbConnection.query: " + JSON.stringify(err));
self.cb(true);
return;
}
console.log("DbConnection results: " + JSON.stringify(results));
self.cb(false, results);
}
function with_connection(sql, bindings, cb) {
var dbc = new DbConnection(sql, bindings, cb);
pool.getConnection(function (err, conn) { dbc.getConnection(err, conn); });
}
bindを使用すると、何らかの利点があることがわかります。メソッド呼び出しに自分自身を転送することを除いて、あまり何もしなかった私が作成したややcreatedい匿名関数を取り除くことができます。 thisの間違った値に関係していたため、メソッドを直接渡すことができませんでした。ただし、bindを使用すると、thisの値を指定できます。
function DbConnection(sql, bindings, cb) {
this.sql = sql;
this.bindings = bindings;
this.cb = cb;
}
DbConnection.prototype.getConnection = function(err, conn) {
var f = this.query.bind(this);
if (err) {
console.log("Error in DbConnection.getConnection: " + JSON.stringify(err));
this.cb(true);
return;
}
conn.query(this.sql, this.bindings, f);
}
DbConnection.prototype.query = function(err, results) {
if (err) {
console.log("Error in DbConnection.query: " + JSON.stringify(err));
this.cb(true);
return;
}
console.log("DbConnection results: " + JSON.stringify(results));
this.cb(false, results);
}
// Get a connection from the pool, execute `sql` in it
// with the given `bindings`. Invoke `cb(true)` on error,
// invoke `cb(false, results)` on success. Here,
// `results` is an array of results from the query.
function with_connection(sql, bindings, cb) {
var dbc = new DbConnection(sql, bindings, cb);
var f = dbc.getConnection.bind(dbc);
pool.getConnection(f);
}
もちろん、これはNode.jsコーディングを使用した適切なJSではありません-ほんの数時間を費やしました。しかし、このテクニックを少し磨いておけば役立つでしょうか？
同じ問題がありました。非同期関数を実行するノードの主要なライブラリを見てきましたが、コードをビルドするために非常に非自然な連鎖（3つ以上のメソッドconfsなどを使用する必要があります）を示しています。
数週間かけて、シンプルで読みやすいソリューションを開発しました。 EnqJS を試してください。すべての意見を歓迎します。
の代わりに：
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
var html = "<h1>Demo page</h1>";
getSomeDate(client, function(someData) {
html += "<p>"+ someData +"</p>";
getSomeOtherDate(client, function(someOtherData) {
html += "<p>"+ someOtherData +"</p>";
getMoreData(client, function(moreData) {
html += "<p>"+ moreData +"</p>";
res.write(html);
res.end();
});
});
});
enqJSの場合：
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
var html = "<h1>Demo page</h1>";
enq(function(){
var self=this;
getSomeDate(client, function(someData){
html += "<p>"+ someData +"</p>";
self.return();
})
})(function(){
var self=this;
getSomeOtherDate(client, function(someOtherData){
html += "<p>"+ someOtherData +"</p>";
self.return();
})
})(function(){
var self=this;
getMoreData(client, function(moreData) {
html += "<p>"+ moreData +"</p>";
self.return();
res.write(html);
res.end();
});
});
});
コードが以前よりも大きく見えることに注意してください。しかし、以前のようにネストされていません。より自然に見えるように、チェーンはすぐに呼び出されます：
enq(fn1)(fn2)(fn3)(fn4)(fn4)(...)
そして、それが返されたと言うには、関数内で呼び出します：
this.return(response)
ファイバーを使用する https://github.com/laverdet/node-fibers 非同期コードを同期のように見せます（ブロッキングなし）
私は個人的にこの小さなラッパーを使用します http://alexeypetrushin.github.com/synchronize 私のプロジェクトのコードのサンプル（すべてのメソッドは実際には非同期で、非同期ファイルIO）コールバックまたは非同期制御フローヘルパーライブラリを使用した場合の混乱を想像することすら恐れています。
_update: (version, changesBasePath, changes, oldSite) ->
@log 'updating...'
@_updateIndex version, changes
@_updateFiles version, changesBasePath, changes
@_updateFilesIndexes version, changes
configChanged = @_updateConfig version, changes
@_updateModules version, changes, oldSite, configChanged
@_saveIndex version
@log "updated to #{version} version"
「step」または「seq」を使用したくない場合は、ネストされた非同期コールバックを削減する単純な関数である「line」を試してください。
私は非常に原始的で効果的な方法でそれを行います。例えば。親と子でモデルを取得する必要があり、それらに対して別々のクエリを実行する必要があるとしましょう。
var getWithParents = function(id, next) {
var getChildren = function(model, next) {
/*... code ... */
return next.pop()(model, next);
},
getParents = function(model, next) {
/*... code ... */
return next.pop()(model, next);
}
getModel = function(id, next) {
/*... code ... */
if (model) {
// return next callbacl
return next.pop()(model, next);
} else {
// return last callback
return next.shift()(null, next);
}
}
return getModel(id, [getParents, getChildren, next]);
}