Если мне нужно вызвать 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

В зависимости от того, нужны ли вам результаты в каждой последующей функции, я бы использовал последовательный, параллельный или водопадный.

Серия, когда они должны выполняться последовательно, но вам не обязательно нужны результаты при каждом последующем вызове функции.

Параллельно если они могут выполняться параллельно, вам не нужны результаты от каждого из них во время выполнения каждой параллельной функции, и вам нужен обратный вызов, когда все завершены.

Водопад, если вы хотите преобразовать результаты в каждой функции и перейти к следующей

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

синхронизация-запрос

Безусловно, самый простой из найденных мной и используемых — это sync-request, и он поддерживает как узел, так и браузер!

 var request = require('sync-request');
var res = request('GET', 'http://google.com');
console.log(res.body.toString('utf-8'));
  

Вот и все, никакой сумасшедшей конфигурации, никаких сложных установок библиотеки, хотя у нее есть резервная библиотека. Просто работает. Я пробовал другие примеры здесь и был поставлен в тупик, когда требовалось выполнить много дополнительных настроек или установки не работали!

Примечания:

Пример, который использует sync-request, не подходит при использовании res.getBody() , все, что делает get body, — это принимает кодировку и преобразует данные ответа. Просто сделайте res.body.toString(encoding) вместо этого.

Вы могли бы сделать это, используя мою общую библиотеку узлов:

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

Я бы использовал рекурсивную функцию со списком 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
});
  

Начиная с 2018 года и используя модули ES6 и Promises, мы можем написать подобную функцию :

 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 ключевого слова)

Другая возможность заключается в настройке обратного вызова, который отслеживает выполненные задачи:

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

Затем просто назначьте каждому идентификатор, и вы сможете настроить свои требования к тому, какие задачи должны быть выполнены перед закрытием соединения.

 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 не предоставляет самых простых синхронных вызовов. Но я понимаю, в чем заключается соблазн асинхронности.

Кажется, решения этой проблемы бесконечны, вот еще одно 🙂

 // do it once.
sync(fs, 'readFile')

// now use it anywhere in both sync or async ways.
var data = fs.readFile(__filename, 'utf8')
  

http://alexeypetrushin.github.com/synchronize

используйте последовательно.

sudo npm устанавливает последовательно

или

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!
  

Использование библиотеки запросов может помочь свести к минимуму количество ошибок:

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

Существует множество библиотек потока управления — мне нравится 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
  })
  

Райнос хорошо ответил на этот вопрос. Тем не менее, с момента публикации ответа в библиотеке последовательностей произошли изменения.

Чтобы заставить последовательность работать, перейдите по этой ссылке: 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);
  

Вот моя версия @andy-shin последовательно с аргументами в массиве вместо индекса:

 function run(funcs, args) {
    var i = 0;
    var recursive = function() {
        funcs[i](function() {
            i  ;
            if (i < funcs.length)
                recursive();
        }, args[i]);
    };
    recursive();
}
  

…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'
            }
        ]
    }
};
  

Взгляните на обзор фреймворка для получения дополнительной информации.

Я попал сюда, потому что мне нужно было ограничить скорость http.request (~ 10 тыс. запросов на агрегацию в elastic search для построения аналитического отчета). Следующее просто заглушило мою машину.

 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-адреса / ключи могут быть помещены в стек за один шаг. Если они вычисляются по ходу выполнения, функция on(‘end’ может отправить следующий URL-адрес в стек непосредственно перед get_top(). Во всяком случае, результат имеет меньшую вложенность, и его может быть проще реорганизовать при изменении вызываемого вами API.

Я понимаю, что это эффективно эквивалентно простой рекурсивной версии @generalhenry выше (поэтому я поддержал это!)

Супер запрос

Это еще один синхронный модуль, который основан на запросе и использует обещания. Супер простой в использовании, хорошо работает с тестами mocha.

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, Promises или включений какой-либо (внешней) библиотеки (кроме нашей собственной).

Вот как это сделать:

Мы собираемся создать модуль C для работы с node.js , и эта функция модуля C выполнит HTTP-запрос и вернет данные в виде строки, и вы можете использовать это напрямую, выполнив:

 var myData = newModule.get(url);
  

ВЫ ГОТОВЫ приступить к работе?

Шаг 1: создайте новую папку где-нибудь еще на вашем компьютере, мы используем эту папку только для сборки модуля.файл узла (скомпилирован с 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, amp;stream, 0, 0);

    char buffer[100];
    unsigned long bytesReadSoFar;
    stringstream ss;
    stream->Read(buffer, 100, amp;bytesReadSoFar);
    while(bytesReadSoFar > 0U) {
        ss.write(buffer, (long long) bytesReadSoFar);
        stream->Read(buffer, 100, amp;bytesReadSoFar);
    }
    stream->Release();
    const string tmp = ss.str();
    const char* cstr = tmp.c_str();
    return S(cstr, is);
}

void Hello(const FunctionCallbackInfo<Value>amp; 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