多くの約束について書かれています。 この記事は、Promiseを使用するための最も実用的なトリックと、これがどのように機能するかについての合理的に詳細な説明をまとめる試みにすぎません。

約束の概要

まず、いくつかの定義。

プロミスは、非同期呼び出しの実行を効率化するオブジェクトです。

非同期呼び出しは、メインコードストリームの実行が呼び出しの終了を待たない関数呼び出しです。 たとえば、http要求はメインスレッドを中断しません。 つまり、要求が実行され、その完了を待たずにすぐに、この呼び出しに続くコードが実行され、http要求の結果が完了後にコールバック関数（コールバック関数）によって処理されます。

次に、promiseの機能を順番に処理します。 ここでは、特定の非同期呼び出しを行うためのpromiseオブジェクトが既にあるという事実から進めます。 約束がどこから来たのか、そしてそれを自分でどのように形成するのかについては後で話します。

1. Promiseは、非同期呼び出しのシーケンスを制御するメカニズムを提供します。 つまり、promiseは非同期呼び出しの単なるラッパーです。 約束は正常に解決される場合と失敗する場合があります。 メカニズムの本質は次のとおりです。 各プロミスは、then（）とcatch（）の2つの関数を提供します。 コールバック関数は、引数として各関数に渡されます。 次に、promiseが正常に解決された場合にコールバック関数が呼び出され、エラーの場合にcatchにコールされます：

promise.then(function(result){ //      }).catch(function(error){ //     }); 

2.次に理解すべき点。 約束は一度だけ許可されます。 つまり、promise内で発生する非同期呼び出しは1回だけ実行されます。 将来的には、promiseは非同期呼び出しの保存された結果を返すだけで、それを実行しなくなります。 たとえば、約束の約束がある場合：

 //    promise.then(function(result){ //      , //       }); //      promise.then(function(result){ //      . //       //   }); 

3. then（）およびcatch（）関数はpromiseを返します。 したがって、約束のチェーンを構築できます。 この場合、コールバック関数がthen（）で返す結果は、後続のthen（）のコールバック関数の入力への引数として渡されます。 また、throw（メッセージ）呼び出しの引数は、catch（）のコールバック関数の引数として渡されます。

 promise.then(function(result){ //    ( ) return result1; //     }).then(function(result){ //  result      result1, //     if(condition){ throw("Error message"); } }).catch(function(error){ //      , //   ,      //    error    "Error message" }); 

4.その結果、then（）のコールバック関数は、何らかの値だけでなく、別のプロミスも返すことができます。 この場合、このプロミスを解決した結果は、then（）の次の呼び出しに転送されます。

 promise1.then(function(result1){ return promise2.then(function(result2){ // -  return result3; }); }).then(function(result){ //   result      result3 }).catch(function(error){ //   }); 

5.アタッチメントなしの1つの線形チェーンでプロミスの解決を構築することにより、同じことを行うことができます。

 promise1.then(function(result1){ return promise2; }).then(function(result2){ // -  return result3; }).then(function(result){ //   result      result3 }).catch(function(error){ //   }); 

各promiseチェーンはcatch（）呼び出しで終了することに注意してください。 これを行わないと、発生したエラーは約束の腸内で消え、エラーが発生した場所を特定することはできなくなります。

まとめると

非同期呼び出しのシーケンスを作成する必要がある場合（つまり、前の呼び出しが完了した後、次の各呼び出しを厳密に完了する必要がある場合）、これらの非同期呼び出しを一連の約束に配置する必要があります。

約束はどこから来るのですか？

約束は2つの方法で受け取ることができます。使用するライブラリの関数が既成の約束を返すか、約束をサポートしない関数への非同期呼び出しを個別に約束に変えることができます（約束）。 各オプションを個別に検討します。

ライブラリ関数の約束

多くの最新ライブラリは、Promiseを使用した作業をサポートしています。 ライブラリがpromiseをサポートしているかどうかは、ドキュメントから確認できます。 一部のライブラリは、コールバック関数とプロミスという非同期呼び出しを処理するための両方のオプションをサポートしています。 人生の例をいくつか考えてみましょう。

ウォーターラインORMデータベースライブラリ

ドキュメントには、ライブラリ関数の使用例が記載されています（データサンプリングの例を使用）。

 Model.find({id: [1,2,3]}).exec(function(error, data){ if(error){ //   } else{ //   ,   data } }); 

すべてが美しいようです。 ただし、データを選択して処理した後、データで他の操作を行う必要がある場合（たとえば、あるテーブルのレコードを更新し、別のテーブルに新しいレコードを挿入する）、コールバック関数のネストは、コードの可読性が急激に低下する傾向があるようになりますゼロ：

 Model.find({id: [1,2,3]}).exec(function(error, data){ if(error){ //   } else{ //   ,   data Model_1.update(...).exec(function(error, data){ if(error){/*   */} else{ //   Model_2.insert(...).exec(function(error, data){ //  .. }); } }); } }); 

与えられた例にメインコードがない場合でも、何が書かれたかを理解することはすでに非常に困難です。 また、データベースクエリをループで実行する必要がある場合、コールバック関数を使用すると、タスクは通常解決できなくなります。

ただし、Waterline ORMライブラリの関数はpromiseで機能しますが、これは何らかの方法でドキュメントに記載されています。 ただし、Promiseを使用すると、人生が大幅に簡素化されます。 データベースクエリ関数がプロミスを返すことがわかりました。 そしてこれは、約束の言語の最後の例を次のように書くことができることを意味します。

 Model.find(...).then(function(data){ //   ,   data return Model_1.update(...); }).then(function(data){ //   return Model_2.insert(...); }).then(function(data){ //  . . }).catch(function(error){ //       }); 

どちらのソリューションが優れているかを言う必要はないと思います。 すべてのエラーの処理が1か所で行われるようになったことは特に喜ばしいことです。 常に良いとは言えませんが。 エラーのコンテキストから、発生した特定のブロックが明確ではないことがあり、デバッグが複雑になります。 この場合、各promiseにcatch（）呼び出しを挿入することを禁止しません。

 Model.find(...).then(function(data){ //   ,   data return Model_1.update(...).catch(function(error){...}); }).then(function(data){ //   return Model_2.insert(...).catch(function(error){...}); }).then(function(data){ //  . . }).catch(function(error){ ... }); 

この場合でも、コードはコールバック関数を使用するよりも理解しやすいです。

MongoDBを操作するためのライブラリ（node.jsのベースライブラリ）

前のケースと同様に、 ドキュメントの例ではコールバック関数を使用しています。

 MongoClient.connect(url, function(err, db) { assert.equal(null, err); console.log("Connected succesfully to server"); db.close(); }); 

前の例で既に見てきたように、コールバックを使用すると、多数の非同期呼び出しを連続して行う必要がある場合に非常に困難になります。 幸いなことに、ドキュメントを注意深く調べてみると、コールバック関数をこのライブラリの関数への引数として渡さない場合、promiseが返されることがわかります。 したがって、前の例は次のように書くことができます。

 MongoClient.connect(url).then(function(db){ console.log("Connected succesfully to server"); db.close(); }).catch(function(err){ //   }); 

このライブラリを使用する特殊性は、データベースへのクエリを実行するために、データベース記述子オブジェクトdbが使用されることです。これは、connect（）への非同期呼び出しの結果として返されます。 つまり、作業中にデータベースに対して多くのクエリを実行する必要がある場合、この記述子を毎回受信する必要があります。 そして、ここで、promiseを使用することでこの問題が美しく解決されます。 これを行うには、データベースに接続するという約束を変数に保存します。

 var dbConnect = MongoClient.connect(url); //   //        dbConnect.then(function(db){ return db.collection('collection_name').find(...); }).then(function(data){ //     //   db   ,  //      return dbConnect.then(function(db){ return db.collection('collection_name').update(...); }); }).then(function(result){ //     update //  .. ... }).catch(function(error){ //   }); //        //      ,    //      dbConnect.then(function(db){ ... }).catch(function(error){ ... }); 

このようなコードの編成で良いのは、データベースへの接続が一度確立されることです（約束は一度だけ許可され、保存された結果が単に返されることを思い出します）。 ただし、上記の例には1つの問題があります。 データベースへのすべてのクエリを完了した後、データベースへの接続を閉じる必要があります。 データベースへの接続を閉じることは、Promiseチェーンの最後に挿入できます。 ただし、起動した2つのチェーンのどちらが早く終了するかはわかりません。つまり、2つのチェーンのどちらをベースへの接続の最後に挿入するかが明確ではありません。 Promise.all（）を呼び出すと、この問題を解決できます。 彼については少し後で説明します。

それまでの間、Promiseを使用して非同期呼び出しをループで編成する方法についての議論は延期します。 結局、前述のように、コールバックを使用してもこの問題をまったく解決できません。

ここで、ライブラリがサポートしていない場合に自分でプロミスを作成する方法の質問に移りましょう。

約束をする（約束）

ライブラリがプロミスをサポートしていないことがよくあります。 そして、コールバックのみを使用することをお勧めします。 小さなスクリプトと単純なロジックの場合、これで満足できます。 しかし、ロジックが複雑な場合は、約束なしにはできません。 そのため、Promiseで非同期呼び出しをラップできる必要があります。

例として、redisリポジトリから属性値を取得するために、非同期関数でプロミスをラップすることを検討してください。 redisライブラリー関数はpromiseをサポートせず、コールバック関数でのみ機能します。 つまり、標準の非同期関数呼び出しは次のようになります。

 var redis = require('redis').createClient(); redis.get('attr_name', function(error, reply){ if(error){ //  } else{ //   } }); 

次に、この関数をpromiseでラップします。 JavaScriptは、このためのPromiseオブジェクトを提供します。 つまり、新しい約束を作成するには、これを行う必要があります。

 new Promise(function(resolve, reject){ //     }); 

関数は引数としてPromiseコンストラクターに渡され、その内部で非同期呼び出しが行われます。 この関数の引数は、resolveおよびreject関数です。 非同期呼び出しが成功した場合、解決関数を呼び出す必要があります。 非同期呼び出しの結果は、resolve関数の入力に渡されます。 エラーが発生した場合は、拒否関数を呼び出す必要があります。 エラーは拒否関数の入力に渡されます。

すべてをまとめると、get（attr）関数が取得され、redisリポジトリからパラメーターを取得するためのプロミスが返されます。

 var redis = require('redis').createClient(); function get(attr){ return new Promise(function(resolve, reject){ redis.get(attr, function(error, reply){ if(error){ reject(error); } else{ resolve(reply); } }); }); } 

以上です。 これで、promiseに対して通常の方法でget（）関数を安全に使用できます。

 get('attr_name').then(function(reply){ //    }).catch(function(error){ //   }); 

なぜこのすべての苦しみ

正気な人なら誰でもこの質問をするでしょう。 結局のところ、私たちは今何をしているのでしょうか？ （非同期）関数呼び出しを順番に実行する方法を説明してきました。 「通常の」（非同期呼び出しで動作しない）プログラミング言語では、これは単に命令を順番に書くことによって行われます。 約束は必要ありません。 そして、単純な一連の呼び出しを行うには、非常に多くの苦痛があります。 たぶん、非同期呼び出しはまったく必要ありませんか？ それらのために非常に多くの問題があります！

しかし、銀の裏地はありません。 非同期呼び出しが存在する場合、呼び出しを行う方法を選択できます：順次または並列。 つまり、あるアクションの実行に別のアクションの結果の存在が必要な場合、promiseでthen（）呼び出しを使用します。 複数のアクションの実行が互いに独立している場合、これらのアクションを並行して開始できます。

いくつかの独立したアクションの並列実行を開始する方法は？ これを行うには、次の呼び出しを使用します。

 Promise.all([ promise_1, promise_2, ..., promise_n ]).then(function(results){ // -    }); 

つまり、promiseの配列がPromise.all関数の入力に渡されます。 この場合のすべての約束はすぐに開始されます。 Promise.all関数は、すべてのPromiseを履行するPromiseを返すため、この場合のthen（）の呼び出しは、配列のすべてのPromiseが履行された後にトリガーされます。 then（）で関数の入力に渡されるresultsパラメーターは、Promise.allの入力に渡された順序でのプロミスの結果の配列です。

もちろん、PromiseはPromise.allに変えることはできず、単に順番に実行するだけです。 ただし、この場合、すべての約束が完了する瞬間の制御が失われます。

約束をループに保つ

多くの場合、サイクル内で一貫して約束を果たすというタスクがあります。 ここでは、promiseが並列的な履行を許可する場合、promise.allの入力に渡す（またはmap、filterなどの関数を使用して）ループでpromiseの配列を構成することは簡単ではないため、promiseの順次履行を正確に検討します。

では、どのように約束をループに保つのでしょうか？ 答えは簡単です-方法はありません。 つまり、厳密に言えば、サイクルで約束を果たすことはできませんが、サイクルでは、次々に満たされる約束のチェーンを作ることができます。これは、周期的な非同期アクションと本質的に同等です。

約束の連鎖の循環的構築のメカニズムの考察に目を向ける。 forループとforEachループという、すべてのプログラマーに馴染みのあるタイプのループを基に構築します。

forループでプロミスチェーンを構築する

何らかのdoSomething（）関数が何らかの非同期アクションを実行する約束を返し、このアクションをn回連続して実行する必要があるとします。 promise自体が、次の非同期呼び出しで使用される文字列の結果を返すようにします。 また、最初の呼び出しが空の文字列で行われたと仮定します。 この場合、一連の約束の構築は次のように行われます。

 //      var actionsChain = Promise.resolve(""); //      for(var i=0; i<n; i++){ actionsChain = actionsChain.then(function(result){ return doSomething(result); }); } // ,      //       actionsChain.then(function(result){ // ,       }).catch(function(error){ //   }); 

このサンプルテンプレートでは、説明が必要なのは最初の行のみです。 残りは、上記の資料から明らかでなければなりません。 Promise.resolve（）関数は正常に解決されたプロミスを返し、その結果はこの関数の引数になります。 つまり、Promise.resolve（ ""）は次と同等です。

 new Promise(function(resolve, reject){ resolve(""); }); 

forEachループでのプロミスチェーンの構築

配列の各要素に対して非同期アクションを実行する必要があるとします。 この非同期アクションをdoSomething（）関数でラップすると、この非同期アクションを実行する約束が返されます。 この場合、約束の連鎖を構築する方法のテンプレートは、奇妙なことに、forEach関数の使用ではなく、reduce関数の使用に基づいています。

開始するには、reduce関数の動作を検討してください。 この関数は、中間結果を維持しながら配列要素を処理するように設計されています。 したがって、最終的には、この配列の積分結果を得ることができます。 たとえば、reduce関数を使用して、配列の要素の合計を計算できます。

 var sum = array.reduce(function(sum, current){ return sum+current; }, 0); 

reduce関数の引数は次のとおりです。

配列の各要素に対して呼び出される関数。 この関数に渡される引数は、前の呼び出しの結果、配列の現在の要素、この要素のインデックス、および配列自体です（上記の例では、最後の2つの引数は必要がないため省略されています）。

配列の最初の要素を処理するときに前のアクションの結果として渡される初期値。

次に、reduce関数を使用してタスクのPromiseのチェーンを構築する方法を見てみましょう。

 array.reduce(function(actionsChain, value){ return actionsChain.then(function(){ return doSomething(value); }); }, Promise.resolve()); 

この例では、前のアクションの結果はactionsChainのプロミスであり、解決後、doSomethingアクションを実行するための新しいプロミスが作成され、結果として返されます。 そのため、配列の各要素に対してチェーンが構築されます。 Promise.resolve（）は、actionsChainの最初の約束として使用されます。

約束を使用するより複雑な例

約束を適用するより複雑な例として、一意の識別子を生成するためのサービスのコードフラグメントを考えます。 サービスの本質は非常に単純です。サービスに対するGET要求ごとに、次の一意の識別子を計算して返します。 ただし、複数の競合するリクエストを同時にサービスに送信できるという事実を考えると、これらのリクエストを後続の実行のためのプロミスのキュー（チェーン）に並べるというタスクが発生します。

サーバーコードは次のようになります。

 //  HTTP- var server = http.createServer(processRequest); //       redis server.on('close', function(){ storage.quit(); }); //   server.listen(config.port, config.host); console.log('Service is listening '+config.host+':'+config.port); 

これは、node.jsで記述されたhttpサーバーの標準コードです。 processRequest関数は、http要求ハンドラーです。 サービス自体はredisストレージを使用してその状態を保存します。 redisの状態持続メカニズムは、この例を理解するのに関係がないため、考慮されません。 ただし、サーバーがシャットダウンしたら、redisで接続を閉じる必要があります。これは上記のコードに反映されています。 唯一重要なことは、リクエストごとにprocessRequest関数が呼び出されることです。 要求キューはrequestQueueの約束です。 次に、コード自体を検討します。

 var requestQueue = Promise.resolve(); /** *    *      * @param {Object} req  * @param {Object} res  */ function processRequest(req, res){ requestQueue = requestQueue .then(function(){ //  GET-, ... if(req.method == 'GET'){ //  UUID  return calcUUID() //     .then(function(uuid){ res.writeHead(200, { 'Content-Type': 'text/plain', 'Cache-Control': 'no-cache' }); res.end(uuid); }) //   .catch(function(error){ console.log(error); res.writeHead(500, { 'Content-Type': 'text/plain', 'Cache-Control': 'no-cache' }); res.end(error); }); } //   GET-,   Bad Request else{ res.statusCode = 400; res.statusMessage = 'Bad Request'; res.end(); } }); } 

calcUUID(), . , . . , , .

おわりに

, , . .

, . - .