只是一个改进版的nkron响应。

const httpGet = url => {
  return new Promise((resolve, reject) => {
    http.get(url, res => {
      res.setEncoding('utf8');
      const body = [];
      res.on('data', chunk => body.push(chunk));
      res.on('end', () => resolve(body.join('')));
    }).on('error', reject);
  });
};

在字符串[]中添加块对内存使用更好，join(")将分配 新的内存只有一次。

只是一个改进版的nkron响应。

const httpGet = url => {
  return new Promise((resolve, reject) => {
    http.get(url, res => {
      res.setEncoding('utf8');
      const body = [];
      res.on('data', chunk => body.push(chunk));
      res.on('end', () => resolve(body.join('')));
    }).on('error', reject);
  });
};

在字符串[]中添加块对内存使用更好，join(")将分配 新的内存只有一次。

http。请求文档包含了如何通过处理数据事件接收响应体的示例:

var options = {
  host: 'www.google.com',
  port: 80,
  path: '/upload',
  method: 'POST'
};

var req = http.request(options, function(res) {
  console.log('STATUS: ' + res.statusCode);
  console.log('HEADERS: ' + JSON.stringify(res.headers));
  res.setEncoding('utf8');
  res.on('data', function (chunk) {
    console.log('BODY: ' + chunk);
  });
});

req.on('error', function(e) {
  console.log('problem with request: ' + e.message);
});

// write data to request body
req.write('data\n');
req.write('data\n');
req.end();

http。Get做的事情与http相同。请求，除非它自动调用req.end()。

var options = {
  host: 'www.google.com',
  port: 80,
  path: '/index.html'
};

http.get(options, function(res) {
  console.log("Got response: " + res.statusCode);

  res.on("data", function(chunk) {
    console.log("BODY: " + chunk);
  });
}).on('error', function(e) {
  console.log("Got error: " + e.message);
});

你需要为请求添加一个监听器，因为node.js是异步工作的:

request.on('response', function (response) {
  response.on('data', function (chunk) {
    console.log('BODY: ' + chunk);
 });
});

一份咖啡:

# My little helper
read_buffer = (buffer, callback) ->
  data = ''
  buffer.on 'readable', -> data += buffer.read().toString()
  buffer.on 'end', -> callback data

# So request looks like
http.get 'http://i.want.some/stuff', (res) ->
  read_buffer res, (response) ->
    # Do some things with your response
    # but don't do that exactly :D
    eval(CoffeeScript.compile response, bare: true)

和编译

var read_buffer;

read_buffer = function(buffer, callback) {
  var data;
  data = '';
  buffer.on('readable', function() {
    return data += buffer.read().toString();
  });
  return buffer.on('end', function() {
    return callback(data);
  });
};

http.get('http://i.want.some/stuff', function(res) {
  return read_buffer(res, function(response) {
    return eval(CoffeeScript.compile(response, {
      bare: true
    }));
  });
});

主体并不是作为响应的一部分完全存储的，这是因为主体可以包含非常大量的数据，如果它被存储在响应对象上，程序的内存将很快被消耗。

相反，Node.js使用一种叫做流的机制。这种机制允许只保留一小部分数据，并允许程序员决定是在内存中完全使用它，还是将数据的每个部分作为其流使用。

有多种方法可以将数据完全消耗到内存中，因为HTTP Response是可读流，所以res对象上所有可读方法都可用

监听“data”事件并保存传递给回调的数据块 Const chunks = [] Res.on ("data"， (chunk) => { chunks.push(块) }); Res.on ("end"， () => { const body = Buffer.concat(chunk); });

当使用这种方法时，您不会干扰流的行为，而只是收集应用程序可用的数据。

使用"readble"事件并调用res.read() Const chunks = []; Res.on ("readable"， () => { 让块; While (null !== (chunk = res.read())){ chunks.push(块) ｝ })； Res.on ("end"， () => { const body = Buffer.concat(chunk); })；

当采用这种方法时，你完全负责流的流，直到res.read被调用，才会有更多的数据被传递到流中。

使用异步迭代器 Const chunks = []; For await (const chunk of readable) { chunks.push(块); ｝ const body = Buffer.concat(chunk);

这种方法类似于“数据”事件方法。它将简化范围，并允许整个过程发生在相同的范围内。

虽然如上所述，完全使用响应中的数据是可能的，但如果确实有必要这样做，始终要记住这一点。在许多情况下，可以简单地将数据定向到目的地，而不将其完全保存到内存中。

Node.js读取流，包括HTTP响应，有一个内置的方法来做这件事，这个方法叫做pipe。用法很简单，readStream.pipe(writeStream);。

例如:

如果数据的最终目的地是文件系统，则可以简单地打开到文件系统的写流，然后将数据通过管道传输到其目的地。

const { createWriteStream } = require("fs");
const writeStream = createWriteStream("someFile");
res.pipe(writeStream);