const http = require('http');
const options = {
    "method":"post",
}
const url = 'http://127.0.0.1/www/enum_select';
const request = http.request(url, options, (res)=>{
    res.setEncoding('utf8');
    res.on('data', (chunk) => {
      console.log(chunk);
    });
    res.on('end', ()=>{
      console.log('==========end==========')
    });
});
request.setHeader('Content-Type', 'application/json');
request.write('{"id":1}', (error)=>{
    console.log(error);
});
request.end();

request.getHeader(name: string) 略

request.setHeader(name: string, value: string) 略

request.removeHeader(name: string) 略

request.end([data[, encoding]][, callback])

完成发送请求。 如果部分请求主体还未发送，则将它们刷新到流中。 如果请求被分块，则发送终止符 '0\r\n\r\n'。
入参
data |
encoding
callback
返回:
如果指定了 data，则相当于调用 request.write(data, encoding) 之后再调用 request.end(callback)。
如果指定了 callback，则当请求流完成时将调用它。

request.flushHeaders()

刷新请求头。
出于效率原因，Node.js 通常会缓冲请求头，直到调用 request.end() 或写入第一个请求数据块。 然后，它尝试将请求头和数据打包到单个 TCP 数据包中。
这通常是期望的（它节省了 TCP 往返），但是可能很晚才发送第一个数据。 request.flushHeaders() 绕过优化并启动请求。

request.setNoDelay([noDelay:boolean]) ???

一旦将套接字分配给此请求并且连接了套接字，就会调用 socket.setNoDelay()。

request.setSocketKeepAlive([enable:boolean][, initialdelay:number])

一旦将套接字分配给此请求并连接了套接字，就会调用 socket.setKeepAlive()。

request.setTimeout(timeout:number[, callback:function])

• 返回:

一旦将套接字分配给此请求并且连接了套接字，就会调用 socket.setTimeout()。

request.abort()

将请求标记为中止。 调用此方法将导致响应中剩余的数据被丢弃并且套接字被销毁。

事件

‘response’ 事件

当收到此请求的响应时触发。 此事件仅触发一次。

...略
const req = http.request(options);
req.on('response', (res: <http.IncomingMessage>) => {
  // ...
});

‘socket’ 事件

• socket

• 将套接字分配给此请求后触发。

  ‘timeout’ 事件

  当底层套接字因不活动而超时时触发。 这只会通知套接字已空闲。 必须手动中止请求。另请参见：request.setTimeout()。

  ‘upgrade’ 事件

• response

• socket
• head

每次服务器响应升级请求时发出。 如果未监听此事件且响应状态码为 101 Switching Protocols，则接收升级响应头的客户端将关闭其连接。

const http = require('http');
// 创建 HTTP 服务器。
const srv = http.createServer( (req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('响应内容');
});
srv.on('upgrade', (req, socket, head) => {
  socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
               'Upgrade: WebSocket\r\n' +
               'Connection: Upgrade\r\n' +
               '\r\n');
  socket.pipe(socket);
});
// 服务器正在运行。
srv.listen(1337, '127.0.0.1', () => {
  // 发送请求。
  const options = {
    port: 1337,
    host: '127.0.0.1',
    headers: {
      'Connection': 'Upgrade',
      'Upgrade': 'websocket'
    }
  };
  const req = http.request(options);
  req.end();
  req.on('upgrade', (res, socket, upgradeHead) => {
    console.log('接收到响应');
    socket.end();
    process.exit(0);
  });
});

‘connect’ 事件

target.on('connect', (
    response :<http.IncomingMessage>,
  socket :<net.Socket>,
  head :<Buffer>
) => {
    // ...
})

每次服务器使用 CONNECT 方法响应请求时都会触发。 如果未监听此事件，则接收 CONNECT 方法的客户端将关闭其连接。

const http = require('http');
const net = require('net');
const url = require('url');
// 创建 HTTP 隧道代理。
const proxy = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('响应内容');
});
proxy.on('connect', (req, cltSocket, head) => {
  // 连接到原始服务器。
  const srvUrl = url.parse(`http://${req.url}`);
  const srvSocket = net.connect(srvUrl.port, srvUrl.hostname, () => {
    cltSocket.write('HTTP/1.1 200 Connection Established\r\n' +
                    'Proxy-agent: Node.js-Proxy\r\n' +
                    '\r\n');
    srvSocket.write(head);
    srvSocket.pipe(cltSocket);
    cltSocket.pipe(srvSocket);
  });
});
// 代理正在运行。
proxy.listen(1337, '127.0.0.1', () => {
  // 向隧道代理发出请求。
  const options = {
    port: 1337,
    host: '127.0.0.1',
    method: 'CONNECT',
    path: 'nodejs.cn:80'
  };
  const req = http.request(options);
  req.end();
  req.on('connect', (res, socket, head) => {
    console.log('已连接');
    // 通过 HTTP 隧道发出请求。
    socket.write('GET / HTTP/1.1\r\n' +
                 'Host: nodejs.cn:80\r\n' +
                 'Connection: close\r\n' +
                 '\r\n');
    socket.on('data', (chunk) => {
      console.log(chunk.toString());
    });
    socket.on('end', () => {
      proxy.close();
    });
  });
});

‘abort’ 事件 ？？？

当请求被客户端中止时触发。 此事件仅在第一次调用 abort() 时触发。

‘continue’ 事件 ???

当服务器发送 100 Continue HTTP 响应时触发，通常是因为请求包含 Expect: 100-continue。 这是客户端应发送请求主体的指令。

‘information’ 事件 ???

服务器发送 1xx 响应时触发（不包括 101 Upgrade）。 使用包含具有状态码的对象的回调触发此事件。

const http = require('http');
const options = {
  host: '127.0.0.1',
  port: 8080,
  path: '/length_request'
};
// 发出请求。
const req = http.request(options);
req.end();
req.on('information', (res) => {
  console.log(`获得主响应之前的信息: ${res.statusCode}`);
});
0 - (未初始化)还没有调用send()方法
1 - (载入)已调用send()方法，正在发送请求
2 - (载入完成)send()方法执行完成，
3 - (交互)正在解析响应内容
4 - (完成)响应内容解析完成，可以在客户端调用了
100——客户必须继续发出请求
101——客户要求服务器根据请求转换HTTP协议版本

属性

request.aborted :number

如果请求已中止，则此值是请求中止的时间，自 1970 年 1 月 1 日 00:00:00 UTC 以来的毫秒数。

request.connection

请参阅 request.socket。

request.finished :boolean

如果调用了 request.end()，则 request.finished 属性将为 true

request.maxHeadersCount :number

限制最大响应头数。 如果设置为 0，则不会应用任何限制。
默认为2000

request.socket

指向底层套接字。 通常用户无需访问此属性。 特别是，由于协议解析器附加到套接字的方式，套接字将不会触发 ‘readable’ 事件。 也可以通过 request.connection 访问 socket。

const http = require('http');
const options = {
  host: 'nodejs.cn',
};
const req = http.get(options);
req.end();
req.once('response', (res) => {
  const ip = req.socket.localAddress;
  const port = req.socket.localPort;
  console.log(`您的 IP 地址是 ${ip}，源端口是 ${port}`);
  // 使用响应对象。
});

http.Server 类

http.ServerResponse 类

http.IncomingMessage 类