Un exemple d'introduction à HTTP dans nodeJS

Les mots précédents

HTTP n'est pas basé sur un langage spécifique. Il s'agit d'un protocole général de couche d'application. Différents langages ont des détails d'implémentation différents, mais ils restent les mêmes et les idées sont les mêmes. En tant qu'environnement d'exploitation hôte, NodeJS utilise JavaScript comme langage hôte. Il possède également son propre ensemble de normes. Cet article présentera en détail le module Http dans nodeJS

Agent

.

【nouvel Agent([options])】

options <Object> 代理的配置选项。有以下字段：
    keepAlive <boolean> 保持 socket 可用即使没有请求，以便它们可被将来的请求使用而无需重新建立一个 TCP 连接。默认为 false。
    keepAliveMsecs <number> 当使用了 keepAlive 选项时，该选项指定 TCP Keep-Alive 数据包的 初始延迟。 当 keepAlive 选项为 false 或 undefined 时，该选项无效。 默认为 1000。
    maxSockets <number> 每个主机允许的最大 socket 数量。 默认为 Infinity。
    maxFreeSockets <number> 在空闲状态下允许打开的最大 socket 数量。 仅当 keepAlive 为 true 时才有效。 默认为 256

Les options http.globalAgent par défaut utilisées par http.request() sont leurs valeurs par défaut respectives

Si pour configurer l'un d'entre eux, vous devez créer une instance http.Agent personnalisée

[agent.createConnection(options[, callback])]

options <Object> 包含连接详情的选项
callback <Function> 接收被创建的 socket 的回调函数。callback 有 (err, stream) 参数
返回: <net.Socket>

Créer un socket ou un flux pour les requêtes HTTP

Par défaut, la fonction est similaire à net.createConnection(). Mais si une plus grande flexibilité est souhaitée, un agent personnalisé peut remplacer cette méthode

Le socket ou le flux peut être obtenu des deux manières suivantes : en revenant de cette fonction ou en passant un rappel

[agent . destroy()]

Détruire toute socket actuellement utilisée par le proxy

Ce n'est généralement pas nécessaire. Mais si vous utilisez un proxy avec keepAlive activé, il est préférable de fermer explicitement le proxy lorsque vous êtes sûr qu'il n'est plus utilisé. Sinon, les sockets peuvent rester ouverts pendant une longue période avant que le serveur n'y mette fin

[agent.freeSockets]

Renvoie un objet contenant les sockets actuellement en attente d'être utilisées par le tableau d'agents compatibles keepAlive. . Ne modifiez pas cet attribut

[agent.getName(options)]

options <Object> 为名称生成程序提供信息的选项。
    host <string> 请求发送至的服务器的域名或 IP 地址。
    port <number> 远程服务器的端口。
    localAddress <string> 当发送请求时，为网络连接绑定的本地接口。
返回: <string>

Obtenez un nom unique pour l'ensemble des options de requête, utilisé pour déterminer si un connexion Peut être réutilisé. Pour les proxys HTTP, renvoie host:port:localAddress. Pour les agents HTTPS, le nom inclura l'autorité de certification, le certificat, le mot de passe et d'autres options spécifiques à HTTPS/TLS utilisées pour déterminer la réutilisabilité du socket

[agent.maxFreeSockets]

La valeur par défaut est 256. Pour les agents avec keepAlive activé, cette propriété peut définir le nombre maximum de sockets inactifs à conserver

[agent.maxSockets]

La valeur par défaut est aucune limite. Cette propriété définit le nombre maximum de sockets simultanés ouverts par l'agent pour chaque origine. La source est une combinaison 'host:port' ou 'host:port:localAddress'

[agent.requests]

　 Renvoie un objet contenant la file d'attente des requêtes qui n'a pas encore été allouée au douille. Ne pas modifier

[agent.sockets]

Renvoie un objet contenant un tableau de sockets actuellement utilisés par l'agent. Ne modifiez pas

Request

[http.ClientRequest]

Cet objet est créé et renvoyé dans http.request(). Il représente une requête en cours de traitement et dont les en-têtes de requête ont été mis en file d'attente. Les en-têtes de requête peuvent toujours être modifiés à l'aide des API setHeader(name, value), getHeader(name) et removeHeader(name). Les en-têtes de requête réels sont envoyés avec le premier morceau de données ou lorsque la connexion est fermée

Pour obtenir la réponse, ajoutez un écouteur pour l'événement 'response' à l'objet de requête. Lorsque l'en-tête de réponse est reçu, l'événement « réponse » est déclenché à partir de l'objet de requête. L'événement « réponse » est exécuté avec un paramètre, qui est une instance http.IncomingMessage. Pendant l'événement « réponse », vous pouvez ajouter un écouteur à l'objet de réponse, par exemple en écoutant l'événement « données »

Si aucun gestionnaire d'événement « réponse » n'est ajouté, la réponse sera entièrement ignorée. Si vous ajoutez un gestionnaire d'événements « réponse », vous devez consommer les données de l'objet de réponse, soit en appelant réponse.read(), en ajoutant un gestionnaire d'événements « données », soit en appelant la méthode .resume(). L'événement « fin » est déclenché lorsque les données sont consommées. La mémoire sera consommée avant la lecture des données, ce qui peut provoquer une erreur de « processus de mémoire insuffisante »

　[Note]Node.js ne vérifie pas si Content-Length est égal à la longueur du corps de la requête transmise

var http = require('http');var server = http.createServer(function(req, res){
    console.log(req.url );//'/'console.log(req.httpVersion );//1.1console.log(req.method );//GET//{"host":"127.0.0.1:5000","connection":"keep-alive","user-agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36","accept":"image/webp,image/*,*/*;q=0.8","referer":"http://127.0.0.1:5000/","accept-encoding":"gzip, deflate, sdch, br","accept-language":"zh-CN,zh;q=0.8,en;q=0.6"}    console.log(JSON.stringify(req.headers) );
    res.end('ok');
});

server.listen(5000);

【abort event】

Déclenché lorsque la requête a été terminée par le client. Cet événement n'est déclenché que lorsque abort() est appelé pour la première fois

【événement aborted】

Déclenché lorsque la requête a été terminée par le serveur et que la socket réseau a été fermée

【événement de connexion】

response <http.IncomingMessage>socket <net.Socket>head <Buffer>

Déclenché lorsque le serveur répond à la requête CONNECT. Si cet événement n'est pas surveillé, le client qui reçoit la méthode CONNECT fermera la connexion

【continue event】

　 Déclenché lorsque le serveur envoie une réponse HTTP 100 Continue, généralement parce que la requête contient Attendez-vous : 100 - continuez. Il s'agit de l'instruction permettant au client d'envoyer le corps de la demande

【événement de réponse】

response <http.IncomingMessage>

Déclenché lorsque la réponse à la demande est reçue. Cet événement n'est déclenché qu'une seule fois

[événement socket]

socket <net.Socket>

Il est déclenché lorsque le socket est affecté à la requête

[upgrade événement]

response <http.IncomingMessage>socket <net.Socket>head <Buffer>

　　每当服务器响应 upgrade 请求时触发。 如果该事件未被监听，则接收到 upgrade 请求头的客户端会关闭连接

【request.abort()】

　　标记请求为终止。 调用该方法将使响应中剩余的数据被丢弃且 socket 被销毁

【request.aborted】

　　如果请求已被终止，则该属性的值为请求被终止的时间，从 1 January 1970 00:00:00 UTC 到现在的毫秒数

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

data <string> | <Buffer>encoding <string>callback <Function>

　　结束发送请求。 如果部分请求主体还未被发送，则会刷新它们到流中。 如果请求是分块的，则会发送终止字符 '0\r\n\r\n'。

　　如果指定了 data，则相当于调用 response.write(data, encoding) 之后再调用 request.end(callback)。

　　如果指定了 callback，则当请求流结束时会被调用

【request.flushHeaders()】

　　刷新请求头

　　出于效率的考虑，Node.js 通常会缓存请求头直到 request.end() 被调用或第一块请求数据被写入。 然后 Node.js 会将请求头和数据打包成一个单一的 TCP 数据包。通常那是期望的（因为它节省了 TCP 往返），除非第一个数据块很长时间之后才被发送。 request.flushHeaders() 可以绕过最优选择并提前开始请求

【request.setNoDelay([noDelay])】

noDelay <boolean>

　　一旦 socket 被分配给请求且已连接，socket.setNoDelay() 会被调用

【request.setSocketKeepAlive([enable][, initialDelay])】

enable <boolean>initialDelay <number>

　　一旦 socket 被分配给请求且已连接，socket.setKeepAlive() 会被调用

【request.setTimeout(timeout[, callback])】

timeout <number><Function> 可选的函数，当超时发生时被调用。等同于绑定到 timeout 事件
返回 request

　　一旦 socket 被分配给请求且已连接，socket.setTimeout() 会被调用

【request.write(chunk[, encoding][, callback])】

chunk <string> | <Buffer><string> encoding 参数是可选的，仅当 chunk 是一个字符串时才有效。默认为 'utf8'<Function> callback 参数是可选的，当数据块被刷新时调用
返回 request

　　发送请求主体的一个数据块。 通过多次调用该方法，一个请求主体可被发送到一个服务器，在这种情况下，当创建请求时，建议使用 ['Transfer-Encoding', 'chunked'] 请求头

 

Server

　　大多数nodejs开发者都是冲着开发web server的目的选择了nodejs。借助http模块，可以几行代码就搞定一个超迷你的web server

【http.createServer([requestListener])】

　　该方法创建并返回一个HTTP服务器对象

　　requestListener表示监听到客户端连接的回调函数

var server = http.createServer(function(req,res){});

【server.listen(port[, hostname][, backlog][, callback])】

　　该方法在指定的的端口和主机名上开始接收连接

　　port表示要监听的端口，若不设置，则端口由系统自动分配

　　若忽略主机名hostname，服务器将会接收指向任意IPv4的地址(INADDR_ANY)

　　若监听一个unix socket，需要提供一个文件名而不是主机名和端口

　　若积压量backlog为等待连接队列的最大长度，即允许多少个客户端在队列中存在。实际的长度由操作系统的sysctl设置决定。默认参数值为511

　　最后一个参数callback是异步函数，会作为事件监听器添加到listening事件

server.listen(5000);

【request事件】

　　当有客户端发送请求到该主机和端口的请求的时候触发

　　参数request : http.IncomingMessage的一个实例，通过他我们可以获取到这次请求的一些信息，比如头信息，数据等

　　参数response : http.ServerResponse的一个实例，通过他我们可以向该次请求的客户端输出返回响应

server.on('request',function(request,response){
    console.log('收到信息');
})

　　由于createServer()的参数是requestListener，所以可以把request事件中的回调函数写为createServer()的参数

var server = http.createServer(function(req,res){
    console.log('收到信息');
});

　　于是，利用上面几个方法就可以创建一个简单的server

var http = require('http');var server = http.createServer(function(req,res){
    console.log('收到信息');
});
server.listen(5000);

　　在浏览器地址栏中输入127.0.0.1:5000，控制台会显示'收到信息'这4个字

【checkContinue事件】

request <http.IncomingMessage>response <http.ServerResponse>

　　每当接收到一个带有 HTTP Expect: 100-continue 请求头的请求时触发。 如果该事件未被监听，则服务器会自动响应 100 Continue

　　处理该事件时，如果客户端应该继续发送请求主体，则调用 response.writeContinue()，否则生成一个适当的 HTTP 响应（例如 400 错误请求）。

　　[注意]当该事件被触发且处理后，request 事件不会被触发

【checkExpectation事件】

request <http.ClientRequest>response <http.ServerResponse>

　　每当接收到一个带有 HTTP Expect 请求头（值不为 100-continue）的请求时触发。 如果该事件未被监听，则服务器会自动响应 417 Expectation Failed。

　　[注意]当该事件被触发且处理后，request 事件不会被触发

【clientError事件】

exception socket <net.Socket> socket 参数是发生错误的 net.Socket 对象

　　如果客户端触发了一个error事件，则它会被传递到这里。该事件的监听器负责关闭或销毁底层的socket。例如，用户可能希望更温和地用HTTP '400 Bad Request'响应关闭 socket，而不是突然地切断连接

　　默认情况下，请求异常时会立即销毁 socket

var http = require('http');var server = http.createServer((req, res) => {
  res.end();
});
server.on('clientError', (err, socket) => {
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
});
server.listen(8000);

　　当 'clientError' 事件发生时，不会有 request 或 response 对象，所以发送的任何 HTTP 响应，包括响应头和内容，必须被直接写入到 socket 对象。 注意，确保响应是一个被正确格式化的 HTTP 响应消息

【close事件】

　　当服务器关闭时触发

【connect事件】

request  HTTP 请求，同 request 事件。
socket <net.Socket> 服务器与客户端之间的网络 socket。
head  流的第一个数据包，可能为空。

　　当客户端发送HTTP CONNECT请求时触发。 如果该事件未被监听，则发送CONNECT请求的客户端会关闭连接

　　当该事件被触发后，请求的 socket 上没有 data 事件监听器，这意味着需要绑定 data 事件监听器，用来处理 socket 上被发送到服务器的数据

【connection 事件】

socket <net.Socket>

　　当一个新的 TCP 流被建立时触发。 socket 是一个 net.Socket 类型的对象。 通常用户无需访问该事件。 注意，因为协议解析器绑定到 socket 的方式，socket 不会触发 'readable' 事件。 socket 也可以通过 request.connection 访问

【upgrade事件】

request  HTTP 请求，同 'request' 事件。
socket <net.Socket> 服务器与客户端之间的网络 socket。
head  流的第一个数据包，可能为空。

　　每当客户端发送HTTP upgrade请求时触发。 如果该事件未被监听，则发送upgrade请求的客户端会关闭连接

　　当该事件被触发后，请求的 socket 上没有 'data' 事件监听器，这意味着需要绑定 'data' 事件监听器，用来处理 socket 上被发送到服务器的数据

【server.close([callback])】

　　停止服务端接收新的连接

【server.listening】

<boolean>

　　返回一个布尔值，表示服务器是否正在监听连接

【server.maxHeadersCount】

<number> 默认为 2000

　　限制请求头的最大数量，默认为 2000。 如果设为 0，则没有限制

【server.setTimeout([msecs][, callback])】

msecs <number> 默认为 120000 (2<Function>
返回 server

　　设置socket的超时时间。 如果发生超时，则触发服务器对象的'timeout'事件，并传入socket作为一个参数

　　默认情况下，服务器的超时时间是 2 分钟，且超时后的 socket 会被自动销毁。 但是，如果你为服务器的 'timeout' 事件分配了一个回调函数，则超时必须被显式地处理

【server.timeout】

<number> 超时时间，以毫秒为单位。默认为 120000 (2 分钟)

　　socket 被认定为超时的空闲毫秒数。值设为 0 可禁用请求连接的超时行为

　　[注意]socket 的超时逻辑是在连接上设定的，所以改变这个值只影响服务器新建的连接，而不会影响任何已存在的连接

 

response

　　该对象在 HTTP 服务器内部被创建。 它作为第二个参数被传入 'request' 事件。这个类实现了（而不是继承自）可写流接口

var http = require('http');var server = http.createServer(function(req, res){
    res.writeHead(200, {'Content-Type': 'text/plain;charset=utf-8'});
    res.end('小火柴');
});
server.listen(8000);

【close事件】

　　当底层连接在 response.end() 被调用或能够刷新之前被终止时触发

【finish事件】

　　当响应已被发送时触发。 更具体地说，当响应头和响应主体的最后一部分已被交给操作系统通过网络进行传输时，触发该事件。 这并不意味着客户端已接收到任何东西。该事件触发后，响应对象上不再触发其他事件

【response.addTrailers(headers)】

headers <Object>

　　该方法会添加 HTTP 尾部响应头（一种在消息尾部的响应头）到响应。

　　仅当响应使用分块编码时，尾部响应头才会被发送；否则（比如请求为 HTTP/1.0），尾部响应头会被丢弃。

　　[注意]发送尾部响应头之前，需先发送 Trailer 响应头，并在值里带上尾部响应头字段的列表

response.writeHead(200, { 'Content-Type': 'text/plain',                          'Trailer': 'Content-MD5' });
response.write(fileData);
response.addTrailers({'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667'});
response.end();

　　如果尾部响应头字段的名称或值包含无效字符，则抛出 TypeError 错误

【response.end([data][, encoding][, callback])】

data <string> | <Buffer>encoding <string> 如果指定了 data，则相当于调用 response.write(data, encoding) 之后再调用 response.end(callback)callback <Function> 如果指定了 callback，则当响应流结束时被调用

　　该方法会通知服务器，所有响应头和响应主体都已被发送，即服务器将其视为已完成。 每次响应都必须调用 response.end() 方法

【response.finished】

<boolean>

　　返回一个布尔值，表示响应是否已完成。 默认为 false。 执行 response.end() 之后，该值会变为 true

【response.getHeader(name)】

name <string>返回: <string>

　　读取一个已入队列但尚未发送到客户端的响应头

　　[注意]名称不区分大小写

var contentType = response.getHeader('content-type');

【response.getHeaderNames()】

　　返回响应头名称的数组

response.setHeader('Foo', 'bar');
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);var headerNames = response.getHeaderNames();// headerNames === ['foo', 'set-cookie']

【response.getHeaders()】

　　返回响应头数组

response.setHeader('Foo', 'bar');
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);var headers = response.getHeaders();// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }

【response.hasHeader(name)】

　　是否包含当前响应头

var hasContentType = response.hasHeader('content-type');

【response.headersSent】

　　返回一个布尔值（只读）。 如果响应头已被发送则为 true，否则为 false

【response.removeHeader(name)】

　　从隐式发送的队列中移除一个响应头

response.removeHeader('Content-Encoding');

【response.sendDate】

　　当为 true 时，如果响应头里没有日期响应头，则日期响应头会被自动生成并发送。默认为 true。

　　该属性只可在测试时被禁用，因为 HTTP 响应需要包含日期响应头

【response.setHeader(name, value)】

name <string>value <string> | <string[]>

　　为一个隐式的响应头设置值。 如果该响应头已存在，则值会被覆盖。 如果要发送多个名称相同的响应头，则使用字符串数组

response.setHeader('Content-Type', 'text/html');
response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']);

　　如果响应头字段的名称或值包含无效字符，则抛出 TypeError 错误

　　response.setHeader()设置的响应头与response.writeHead()设置的响应头合并，response.writeHead()优先

【response.setTimeout(msecs[, callback])】

msecs <number><Function>
返回 response

　　设置socket的超时时间为msecs。如果提供了回调函数，它会作为监听器被添加到响应对象的'timeout'事件

　　如果没有 'timeout' 监听器被添加到请求、响应或服务器，则 socket 会在超时后被销毁。 如果在请求、响应或服务器的 'timeout' 事件上分配了回调函数，则超时的 socket 必须被显式地处理

【response.statusCode】

　　当使用隐式的响应头时（没有显式地调用 response.writeHead()），该属性控制响应头刷新时将被发送到客户端的状态码

response.statusCode = 404;

　　响应头被发送到客户端后，该属性表示被发出的状态码

【response.statusMessage】

　　当使用隐式的响应头时（没有显式地调用 response.writeHead()），该属性控制响应头刷新时将被发送到客户端的状态信息。 如果该值为 undefined，则使用状态码的标准信息

response.statusMessage = 'Not found';

　　响应头被发送到客户端后，该属性表示被发出的状态信息

【response.write(chunk[, encoding][, callback])】

chunk <string> | encoding <string>callback <Function>返回: <boolean>

　　如果该方法被调用且 response.writeHead() 没有被调用，则它会切换到隐式响应头模式并刷新隐式响应头。

　　该方法会发送一块响应主体。 它可被多次调用，以便提供连续的响应主体片段

　　chunk 可以是一个字符串或一个 buffer。 如果 chunk 是一个字符串，则第二个参数指定如何将它编码成一个字节流。 encoding 默认为 'utf8'。 当数据块被刷新时，callback 会被调用。

　　[注意]这是原始的 HTTP 主体，且与可能被使用的高级主体编码无关

【response.write()】

　　首次被调用时，会发送缓冲的响应头信息和响应主体的第一块数据到客户端。 response.write() 第二次被调用时，Node.js 会以流的形式处理数据，并将它们分别发送。 也就是说，响应会被缓冲到响应主体的第一个数据块。

　　如果全部数据被成功刷新到内核缓冲区，则返回 true。 如果全部或部分数据还在内存中排队，则返回 false。 当缓冲区再次空闲时，则触发 'drain' 事件

【response.writeContinue()】

　　发送一个 HTTP/1.1 100 Continue 消息到客户端，表示请求主体可以开始发送

【response.writeHead(statusCode[, statusMessage][, headers])】

statusCode <number>  状态码是一个三位数的 HTTP 状态码，如 404statusMessage <string> statusMessage 是可选的状态描述headers <Object> headers 是响应头

　　发送一个响应头给请求

var body = 'hello world';
response.writeHead(200, {  'Content-Length': Buffer.byteLength(body),  'Content-Type': 'text/plain' });

　　该方法在消息中只能被调用一次，且必须在 response.end() 被调用之前调用。

　　如果在调用该方法之前调用 response.write() 或 response.end()，则隐式的响应头会被处理并调用该函数。

　　response.setHeader() 设置的响应头会与 response.writeHead() 设置的响应头合并，且 response.writeHead() 的优先

// 返回 content-type = text/plainvar server = http.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('ok');
});

　　[注意]Content-Length 是以字节（而不是字符）为单位的。如果响应主体包含高级编码的字符，则应使用 Buffer.byteLength() 来确定在给定编码中的字节数。 Node.js 不会检查 Content-Length 与已发送的响应主体的长度是否相同。

　　如果响应头字段的名称或值包含无效字符，则抛出 TypeError 错误

 

IncomingMessage

　　IncomingMessage 对象由 http.Server 或 http.ClientRequest 创建，并作为第一个参数分别递给 'request' 和 'response' 事件。 它可以用来访问响应状态、消息头、以及数据。它实现了 可读流 接口

【aborted事件】

　　当请求已被客户端终止且网络 socket 已关闭时触发

【close事件】

　　当底层连接被关闭时触发。 同 end 事件一样，该事件每个响应只触发一次

【message.destroy([error])】

　　调用接收到 IncomingMessage 的 socket 上的 destroy() 方法。 如果提供了 error，则触发 error 事件，且把 error 作为参数传入事件的监听器

【message.headers】

<Object>

　　请求头或响应头的对象

　　头信息的名称与值的键值对。 头信息的名称为小写

// { 'user-agent': 'curl/7.22.0',//   host: '127.0.0.1:8000',//   accept: '*/*' }console.log(request.headers);

【message.httpVersion】

<string>

　　在服务器请求中，该属性返回客户端发送的 HTTP 版本。在客户端响应中，该属性返回连接到的服务器的 HTTP 版本。 可能的值有 '1.1' 或 '1.0'

　　message.httpVersionMajor 返回 HTTP 版本的第一个整数值，message.httpVersionMinor 返回 HTTP 版本的第二个整数值

【message.method】

　　返回一个字符串，表示请求的方法。 该属性只读。 例如：'GET'、'DELETE'。

　　[注意]仅在 http.Server 返回的请求中有效。

【message.rawHeaders】

<Array>

　　接收到的原始的请求头或响应头列表。

　　[注意]键和值在同一个列表中。 偶数位的是键，奇数位的是对应的值。

　　头信息的名称不会被转换为小写，重复的也不会被合并

// [ 'user-agent',//   'this is invalid because there can be only one',//   'User-Agent',//   'curl/7.22.0',//   'Host',//   '127.0.0.1:8000',//   'ACCEPT',//   '*/*' ]console.log(request.rawHeaders);

【message.rawTrailers】

<Array>

　　接收到的原始的 Trailer 请求头或响应头的的键和值。 只在 'end' 事件时被赋值

【message.setTimeout(msecs, callback)】

msecs <number>callback <Function>返回 message

　　调用 message.connection.setTimeout(msecs, callback)

【message.socket】

<net.Socket>

　　返回与连接关联的 net.Socket 对象。

　　通过 HTTPS 的支持，使用 request.socket.getPeerCertificate() 获取客户端的认证信息

【message.statusCode】

<number>

　　返回一个三位数的 HTTP 响应状态码。 如 404

　　[注意]仅在 http.ClientRequest 返回的响应中有效。

【message.statusMessage】

<string>

　　仅在 http.ClientRequest 返回的响应中有效。

　　返回 HTTP 响应状态消息（原因描述）。 如 OK 或 Internal Server Error

【message.trailers】

<Object>

　　返回 Trailer 请求头或响应头对象。 只在 'end' 事件时被赋值

【message.url】

<string>

　　返回请求的 URL 字符串。 仅包含实际 HTTP 请求中的 URL

　　[注意]仅在 http.Server 返回的请求中有效

 

HTTP

【http.METHODS】

<Array>

　　返回解析器支持的 HTTP 方法的列表

【http.STATUS_CODES】

<Object>

　　返回标准的 HTTP 响应状态码的集合，以及各自的简短描述

http.STATUS_CODES[404] === 'Not Found'

【http.createServer([requestListener])】

requestListener <Function> requestListener 是一个函数，会被自动添加到 'request' 事件返回: <http.Server>

　　返回一个新建的 http.Server 实例

【http.get(options[, callback])】

options <Object> | <string> callback <Function>返回: 

　　因为大多数请求都是 GET 请求且不带请求主体，所以 Node.js 提供了该便捷方法。 该方法与 http.request() 唯一的区别是它设置请求方法为 GET 且自动调用 req.end()。 注意，响应数据必须在回调中被消耗

　　callback 被调用时只传入一个参数，该参数是 http.IncomingMessage 的一个实例

var http = require('http');
http.get('http://127.0.0.1:3000', function(res){
    console.log(res.statusCode);//200});

【http.globalAgent】

<http.Agent>

　　Agent 的全局实例，作为所有 HTTP 客户端请求的默认 Agent

【http.request(options[, callback])】

options <Object> | <string> options是一个对象或字符串。如果是一个字符串，它会被自动使用url.parse()解析protocol <string> 使用的协议。默认为 http:。
    host <string> 请求发送至的服务器的域名或 IP 地址。默认为 localhost。
    hostname <string> host 的别名。为了支持 url.parse()，hostname 优于 host。
    family <number> 当解析host和hostname时使用的IP地址族。 有效值是4或6。当未指定时，则同时使用IPv4和v6
    port <number> 远程服务器的端口。默认为 80。
    localAddress <string> 为网络连接绑定的本地接口。
    socketPath <string> Unix 域 Socket（使用 host:port 或 socketPath）。
    method <string> 指定 HTTP 请求方法的字符串。默认为 'GET'。
    path <string> 请求的路径。默认为 '/'。 应包括查询字符串（如有的话）。如 '/index.html?page=12'。 当请求的路径中包含非法字符时，会抛出异常。 目前只有空字符会被拒绝，但未来可能会变化。
    headers <Object> 包含请求头的对象。
    auth <string> 基本身份验证，如 'user:password' 用来计算 Authorization 请求头。
    agent <http.Agent> | <boolean> 控制 Agent 的行为。 可能的值有：
        undefined (默认): 对该主机和端口使用 http.globalAgent。
        Agent 对象：显式地使用传入的 Agent。false: 创建一个新的使用默认值的 Agent。
    createConnection  当不使用 agent 选项时，为请求创建一个 socket 或流。 这可以用于避免仅仅创建一个自定义的 Agent 类来覆盖默认的 createConnection 函数。详见 agent.createConnection()。
    timeout <number>: 指定 socket 超时的毫秒数。 它设置了 socket 等待连接的超时时间。
callback <Function> 可选的 callback 参数会作为单次监听器被添加到 'response' 事件

　　Node.js 为每台服务器维护多个连接来进行 HTTP 请求。 该函数允许显式地发出请求。http.request() 返回一个 http.ClientRequest 类的实例。 ClientRequest 实例是一个可写流。 如果需要通过 POST 请求上传一个文件，则写入到 ClientRequest 对象

 

https

　　HTTPS 是 HTTP 基于 TLS/SSL 的版本。在 Node.js 中，它被实现为一个独立的模块

【server.setTimeout([msecs][, callback])】

msecs <number> Defaults to 120000 (2 minutes).
callback <Function>

【server.timeout】

<number> Defaults to 120000 (2 minutes)

【server.keepAliveTimeout】

<number> Defaults to 5000 (5 seconds)

【server.close([callback])】

callback <Function>

【server.listen([port][, host][, backlog][, callback])】

port <number>hostname <string>backlog <number>callback <Function>

【https.createServer(options[, requestListener])】

options <Object>requestListener 

【https.get(options[, callback])】

options <Object> | <string> options是一个对象或是字符串。如果是字符串, 它自动被url.parse()所解析
callback <Function>

　　类似 http.get()，但是用于 HTTPS

　　参数 options 可以是一个对象或是一个字符串。 如果参数 options 是一个字符串, 它自动被 url.parse() 所解析

【https.globalAgent】

　　https.Agent的全局实例，用于所有HTTPS客户端请求

【https.request(options[, callback])】

options <Object> | <string> 
    protocol Defaults to https:
    port Defaults to 443.
    agent Defaults to https.globalAgent.
callback <Function>

　　向一个安全的服务器发起一个请求

　　参数options可以是一个对象或是一个字符串。如果一个字符串，它自动被 url.parse()所解析

 

应用

【简单的GET请求】

var https = require('https');
https.get('https://www.cnblogs.com/', function(res){var data = '';
    res.setEncoding('utf8');
    res.on('data', function(chunk){
        data += chunk;
    });
    res.on('end', function(){
        console.log(data);
    });
});

【简单的POST请求】

var http = require('http');var querystring = require('querystring');var createClientPostRequest = function(){var options = {
        method: 'POST',
        protocol: 'http:',
        hostname: '127.0.0.1',
        port: '3000',
        path: '/post',
        headers: {"connection": "keep-alive","content-type": "application/x-www-form-urlencoded"}    
    };// 发送给服务端的数据var postBody = {
        a: '1'};// 创建客户端请求var client = http.request(options, function(res){// 最终输出：Server got client data: nick=chyingp        res.pipe(process.stdout);  
    });// 发送的报文主体，记得先用 querystring.stringify() 处理下    client.write( querystring.stringify(postBody) );
    client.end();
};// 服务端程序，只是负责回传客户端数据var server = http.createServer(function(req, res){
    res.write('Server got client data: ');
    req.pipe(res);
});
server.listen(3000, createClientPostRequest);

 

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!