Node.jsでの同期リクエスト
3つのHTTP APIを順番に呼び出す必要がある場合、次のコードのより良い代替手段は何でしょうか。
http.get({ Host: 'www.example.com', path: '/api_1.php' }, function(res) {
res.on('data', function(d) {
http.get({ Host: 'www.example.com', path: '/api_2.php' }, function(res) {
res.on('data', function(d) {
http.get({ Host: 'www.example.com', path: '/api_3.php' }, function(res) {
res.on('data', function(d) {
});
});
}
});
});
}
});
});
}
Futures のような遅延を使用します。
var sequence = Futures.sequence();
sequence
.then(function(next) {
http.get({}, next);
})
.then(function(next, res) {
res.on("data", next);
})
.then(function(next, d) {
http.get({}, next);
})
.then(function(next, res) {
...
})
スコープを渡す必要がある場合は、このようなことをしてください
.then(function(next, d) {
http.get({}, function(res) {
next(res, d);
});
})
.then(function(next, res, d) { })
...
})
Raynosのソリューションも気に入っていますが、別のフロー制御ライブラリの方が好きです。
https://github.com/caolan/async
後続の各関数で結果が必要かどうかに応じて、直列、並列、またはウォーターフォールのいずれかを使用します。
Series 連続して実行する必要があるが、以降の各関数呼び出しで必ずしも結果が必要とは限らない場合。
Parallel 並列で実行できる場合、各並列関数中にそれぞれの結果を必要とせず、すべてが完了したときにコールバックが必要です。
Waterfall 各関数の結果をモーフィングして次の関数に渡す場合
endpoints =
[{ Host: 'www.example.com', path: '/api_1.php' },
{ Host: 'www.example.com', path: '/api_2.php' },
{ Host: 'www.example.com', path: '/api_3.php' }];
async.mapSeries(endpoints, http.get, function(results){
// Array of results
});
Common Node library を使用してこれを行うことができます。
function get(url) {
return new (require('httpclient').HttpClient)({
method: 'GET',
url: url
}).finish().body.read().decodeToString();
}
var a = get('www.example.com/api_1.php'),
b = get('www.example.com/api_2.php'),
c = get('www.example.com/api_3.php');
同期リクエスト
私が見つけて使用した中で最も簡単なのは sync-request で、ノードとブラウザーの両方をサポートしています！
var request = require('sync-request');
var res = request('GET', 'http://google.com');
console.log(res.body.toString('utf-8'));
Libフォールバックはありますが、それでおかしな設定や複雑なlibのインストールはありません。ただ動作します。ここで他の例を試してみましたが、追加のセットアップが必要な場合やインストールが機能しない場合に困惑しました！
ノート：
sync-request が使用する例は、res.getBody()を使用する場合、Niceを再生しません。getbodyが行うすべては、エンコードを受け入れ、応答データを変換することです。代わりにres.body.toString(encoding)を実行してください。
私はAPIのリストで再帰関数を使用します
var APIs = [ '/api_1.php', '/api_2.php', '/api_3.php' ];
var Host = 'www.example.com';
function callAPIs ( Host, APIs ) {
var API = APIs.shift();
http.get({ Host: Host, path: API }, function(res) {
var body = '';
res.on('data', function (d) {
body += d;
});
res.on('end', function () {
if( APIs.length ) {
callAPIs ( Host, APIs );
}
});
});
}
callAPIs( Host, APIs );
編集：要求バージョン
var request = require('request');
var APIs = [ '/api_1.php', '/api_2.php', '/api_3.php' ];
var Host = 'www.example.com';
var APIs = APIs.map(function (api) {
return 'http://' + Host + api;
});
function callAPIs ( Host, APIs ) {
var API = APIs.shift();
request(API, function(err, res, body) {
if( APIs.length ) {
callAPIs ( Host, APIs );
}
});
}
callAPIs( Host, APIs );
編集：リクエスト/非同期バージョン
var request = require('request');
var async = require('async');
var APIs = [ '/api_1.php', '/api_2.php', '/api_3.php' ];
var Host = 'www.example.com';
var APIs = APIs.map(function (api) {
return 'http://' + Host + api;
});
async.eachSeries(function (API, cb) {
request(API, function (err, res, body) {
cb(err);
});
}, function (err) {
//called when all done, or error occurs
});
別の可能性は、完了したタスクを追跡するコールバックを設定することです：
function onApiResults(requestId, response, results) {
requestsCompleted |= requestId;
switch(requestId) {
case REQUEST_API1:
...
[Call API2]
break;
case REQUEST_API2:
...
[Call API3]
break;
case REQUEST_API3:
...
break;
}
if(requestId == requestsNeeded)
response.end();
}
次に、それぞれにIDを割り当てるだけで、接続を閉じる前にタスクを完了する必要がある要件を設定できます。
const var REQUEST_API1 = 0x01;
const var REQUEST_API2 = 0x02;
const var REQUEST_API3 = 0x03;
const var requestsNeeded = REQUEST_API1 | REQUEST_API2 | REQUEST_API3;
さて、それはきれいではありません。これは、順次呼び出しを行う別の方法です。 NodeJSが最も基本的な同期呼び出しを提供しないのは残念です。しかし、非同期性に対するルアーとは何かを理解しています。
この問題の解決策は終わりがないようです、もう1つあります:)
// do it once.
sync(fs, 'readFile')
// now use it anywhere in both sync or async ways.
var data = fs.readFile(__filename, 'utf8')
順番に使用します。
Sudo npm install sequenty
または
https://github.com/AndyShin/sequenty
とても簡単です。
var sequenty = require('sequenty');
function f1(cb) // cb: callback by sequenty
{
console.log("I'm f1");
cb(); // please call this after finshed
}
function f2(cb)
{
console.log("I'm f2");
cb();
}
sequenty.run([f1, f2]);
また、次のようなループを使用できます。
var f = [];
var queries = [ "select .. blah blah", "update blah blah", ...];
for (var i = 0; i < queries.length; i++)
{
f[i] = function(cb, funcIndex) // sequenty gives you cb and funcIndex
{
db.query(queries[funcIndex], function(err, info)
{
cb(); // must be called
});
}
}
sequenty.run(f); // fire!
request ライブラリを使用すると、問題を最小限に抑えることができます。
var request = require('request')
request({ uri: 'http://api.com/1' }, function(err, response, body){
// use body
request({ uri: 'http://api.com/2' }, function(err, response, body){
// use body
request({ uri: 'http://api.com/3' }, function(err, response, body){
// use body
})
})
})
しかし、最大限の効果を得るには、Stepなどの制御フローライブラリを試す必要があります。許容範囲内であれば、リクエストを並列化することもできます。
var request = require('request')
var Step = require('step')
// request returns body as 3rd argument
// we have to move it so it works with Step :(
request.getBody = function(o, cb){
request(o, function(err, resp, body){
cb(err, body)
})
}
Step(
function getData(){
request.getBody({ uri: 'http://api.com/?method=1' }, this.parallel())
request.getBody({ uri: 'http://api.com/?method=2' }, this.parallel())
request.getBody({ uri: 'http://api.com/?method=3' }, this.parallel())
},
function doStuff(err, r1, r2, r3){
console.log(r1,r2,r3)
}
)
2018年以降、ES6モジュールとPromiseを使用して、次のような関数を作成できます。
import { get } from 'http';
export const fetch = (url) => new Promise((resolve, reject) => {
get(url, (res) => {
let data = '';
res.on('end', () => resolve(data));
res.on('data', (buf) => data += buf.toString());
})
.on('error', e => reject(e));
});
そして、別のモジュールで
let data;
data = await fetch('http://www.example.com/api_1.php');
// do something with data...
data = await fetch('http://www.example.com/api_2.php');
// do something with data
data = await fetch('http://www.example.com/api_3.php');
// do something with data
コードは非同期コンテキストで実行する必要があります（asyncキーワードを使用）
これはレイノスによってよく答えられました。それでも、回答が投稿されて以来、シーケンスライブラリに変更がありました。
シーケンスを機能させるには、次のリンクに従ってください： https://github.com/FuturesJS/sequence/tree/9daf0000289954b85c0925119821752fbfb3521e .
これは、npm install sequenceの後に動作させる方法です：
var seq = require('sequence').Sequence;
var sequence = seq.create();
seq.then(function call 1).then(function call 2);
たくさんの制御フローライブラリがあります-私は conseq が好きです（...私が書いたからです。）また、on('data')は数回起動できるので、RESTを使用します_ restler のようなラッパーライブラリ。
Seq()
.seq(function () {
rest.get('http://www.example.com/api_1.php').on('complete', this.next);
})
.seq(function (d1) {
this.d1 = d1;
rest.get('http://www.example.com/api_2.php').on('complete', this.next);
})
.seq(function (d2) {
this.d2 = d2;
rest.get('http://www.example.com/api_3.php').on('complete', this.next);
})
.seq(function (d3) {
// use this.d1, this.d2, d3
})
... 4年後...
以下に、フレームワーク Danf を使用した元のソリューションを示します（この種のコードは不要で、設定のみが必要です）。
// config/common/config/sequences.js
'use strict';
module.exports = {
executeMySyncQueries: {
operations: [
{
order: 0,
service: 'danf:http.router',
method: 'follow',
arguments: [
'www.example.com/api_1.php',
'GET'
],
scope: 'response1'
},
{
order: 1,
service: 'danf:http.router',
method: 'follow',
arguments: [
'www.example.com/api_2.php',
'GET'
],
scope: 'response2'
},
{
order: 2,
service: 'danf:http.router',
method: 'follow',
arguments: [
'www.example.com/api_3.php',
'GET'
],
scope: 'response3'
}
]
}
};
並行して実行する操作には、同じ
order値を使用します。
さらに短くしたい場合は、収集プロセスを使用できます。
// config/common/config/sequences.js
'use strict';
module.exports = {
executeMySyncQueries: {
operations: [
{
service: 'danf:http.router',
method: 'follow',
// Process the operation on each item
// of the following collection.
collection: {
// Define the input collection.
input: [
'www.example.com/api_1.php',
'www.example.com/api_2.php',
'www.example.com/api_3.php'
],
// Define the async method used.
// You can specify any collection method
// of the async lib.
// '--' is a shorcut for 'forEachOfSeries'
// which is an execution in series.
method: '--'
},
arguments: [
// Resolve reference '@@.@@' in the context
// of the input item.
'@@.@@',
'GET'
],
// Set the responses in the property 'responses'
// of the stream.
scope: 'responses'
}
]
}
};
詳細については、フレームワークの 概要 をご覧ください。
これは、私のバージョンの@ andy-shinに、インデックスではなく配列の引数を続けたものです。
function run(funcs, args) {
var i = 0;
var recursive = function() {
funcs[i](function() {
i++;
if (i < funcs.length)
recursive();
}, args[i]);
};
recursive();
}
Http.requestをレート制限する必要があるため、ここに着陸しました（分析レポートを作成するために、エラスティック検索への集約クエリは最大10,000件）。次は私のマシンを詰まらせました。
for (item in set) {
http.request(... + item + ...);
}
私のURLは非常にシンプルなので、これは元の質問にはさほど当てはまらないかもしれませんが、私のものと似た問題を抱えてここに来て、ささいなJavaScriptのライブラリなしのソリューションを望んでいる読者にとっては、潜在的に適用可能であり、ここで書く価値があると思います。
私の仕事は順序に依存するものではなく、これを回避するための最初のアプローチは、シェルスクリプトでラップしてそれをチャンクすることでした（JavaScriptが初めてなので）。それは機能的でしたが、満足のいくものではありませんでした。最終的に私のJavaScriptの解決策は、次のことをすることでした：
var stack=[];
stack.Push('BOTTOM');
function get_top() {
var top = stack.pop();
if (top != 'BOTTOM')
collect(top);
}
function collect(item) {
http.request( ... + item + ...
result.on('end', function() {
...
get_top();
});
);
}
for (item in set) {
stack.Push(item);
}
get_top();
collectとget_topの間の相互再帰のように見えます。システムが非同期であり、関数collectがon。（ 'end'でイベントのコールバックを隠して完了しているため、それが有効かどうかはわかりません。
元の質問に当てはまるほど一般的だと思います。私のシナリオのように、シーケンス/セットがわかっている場合、すべてのURL /キーを1ステップでスタックにプッシュできます。あなたが行くように計算される場合、on（ 'end'関数はスタックの次のURLをget_top（）の直前にプッシュできます。ネストし、呼び出しているAPIが変更されると、リファクタリングが容易になる場合があります。
これは、上記の@generalhenryの単純な再帰バージョンと事実上同等であることを理解しています（したがって、私はそれを支持しました！）
スーパーリクエスト
これは、リクエストに基づいており、Promiseを使用する別の同期モジュールです。とても使いやすく、モカテストでうまく機能します。
npm install super-request
request("http://domain.com")
.post("/login")
.form({username: "username", password: "password"})
.expect(200)
.expect({loggedIn: true})
.end() //this request is done
//now start a new one in the same session
.get("/some/protected/route")
.expect(200, {hello: "world"})
.end(function(err){
if(err){
throw err;
}
});
このコードは、.then()呼び出しで最終コードを実行できるようになった後、約束の配列を同期的かつ連続的に実行するために使用できます。
const allTasks = [() => promise1, () => promise2, () => promise3];
function executePromisesSync(tasks) {
return tasks.reduce((task, nextTask) => task.then(nextTask), Promise.resolve());
}
executePromisesSync(allTasks).then(
result => console.log(result),
error => console.error(error)
);
Await、Promise、または（外部の）ライブラリ（私たちのライブラリを除く）を含めることなく、実際にあなた（そして私）が望んでいたものを手に入れました。
方法は次のとおりです。
Node.jsに対応するC++モジュールを作成します。そのC++モジュール関数はHTTPリクエストを作成し、データを文字列として返します。次のようにして、直接使用できます。
var myData = newModule.get(url);
準備はできていますか始めましょうか？
ステップ1：コンピューターの別の場所に新しいフォルダーを作成します。このフォルダーを使用してmodule.nodeファイル（C++からコンパイル）を作成するだけで、後で移動できます。
新しいフォルダーに（組織化のためにmynewFolder/srcに配置します）：
npm init
それから
npm install node-gyp -g
次に、2つの新しいファイルを作成します。1、something.cppと呼ばれ、このコードを挿入します（または必要に応じて変更します）。
#pragma comment(lib, "urlmon.lib")
#include <sstream>
#include <WTypes.h>
#include <node.h>
#include <urlmon.h>
#include <iostream>
using namespace std;
using namespace v8;
Local<Value> S(const char* inp, Isolate* is) {
return String::NewFromUtf8(
is,
inp,
NewStringType::kNormal
).ToLocalChecked();
}
Local<Value> N(double inp, Isolate* is) {
return Number::New(
is,
inp
);
}
const char* stdStr(Local<Value> str, Isolate* is) {
String::Utf8Value val(is, str);
return *val;
}
double num(Local<Value> inp) {
return inp.As<Number>()->Value();
}
Local<Value> str(Local<Value> inp) {
return inp.As<String>();
}
Local<Value> get(const char* url, Isolate* is) {
IStream* stream;
HRESULT res = URLOpenBlockingStream(0, url, &stream, 0, 0);
char buffer[100];
unsigned long bytesReadSoFar;
stringstream ss;
stream->Read(buffer, 100, &bytesReadSoFar);
while(bytesReadSoFar > 0U) {
ss.write(buffer, (long long) bytesReadSoFar);
stream->Read(buffer, 100, &bytesReadSoFar);
}
stream->Release();
const string tmp = ss.str();
const char* cstr = tmp.c_str();
return S(cstr, is);
}
void Hello(const FunctionCallbackInfo<Value>& arguments) {
cout << "Yo there!!" << endl;
Isolate* is = arguments.GetIsolate();
Local<Context> ctx = is->GetCurrentContext();
const char* url = stdStr(arguments[0], is);
Local<Value> pg = get(url,is);
Local<Object> obj = Object::New(is);
obj->Set(ctx,
S("result",is),
pg
);
arguments.GetReturnValue().Set(
obj
);
}
void Init(Local<Object> exports) {
NODE_SET_METHOD(exports, "get", Hello);
}
NODE_MODULE(cobypp, Init);
something.gypと呼ばれる同じディレクトリに新しいファイルを作成し、その中に（のような）を入れます：
{
"targets": [
{
"target_name": "cobypp",
"sources": [ "src/cobypp.cpp" ]
}
]
}
Package.jsonファイルに、次を追加します。"gypfile": true,
現在：コンソールで、node-gyp rebuild
コマンド全体を実行し、最後にエラーなしで「OK」と表示された場合、（ほとんど）行っても構いません。そうでない場合は、コメントを残してください。
しかし、それが機能する場合は、build/Release/cobypp.node（またはそれが呼び出されたもの）に移動し、メインのnode.jsフォルダーにコピーしてから、node.jsにコピーします。
var myCPP = require("./cobypp")
var myData = myCPP.get("http://google.com").result;
console.log(myData);
..
response.end(myData);//or whatever