[ 'ConTent-Length', '123456',
'content-LENGTH', '123',
'content-type', 'text/plain',
'CONNECTION', 'keep-alive',
'Host', 'mysite.com',
'accepT', '*/*' ]
http.METHODS
Array
一个被解析器所支持的HTTP方法的列表。
http.STATUS_CODES
Object
一个所有标准HTTP响应状态码的集合,以及它们的简短描述。例如,http.STATUS_CODES[404] === 'Not Found'
。
http.createServer([requestListener])
返回一个新的http.Server
实例
requestListener
是一个会被自动添加为request
事件监听器的函数。
http.createClient([port][, host])
这个函数已经被启用。请使用http.request()
替代。构造一个新的HTTP客户端。port
和host
指定了需要连接的目标服务器。
Class: http.Server
这是一个具有以下事件的EventEmitter
:
Event: 'request'
function (request, response) { }
当有请求来到时触发。注意每一个连接可能有多个请求(在长连接的情况下)。请求是一个http.IncomingMessage
实例,响应是一个http.ServerResponse
实例。
Event: 'connection'
function (socket) { }
当一个新的TCP流建立时触发。socket
是一个net.Socket
类型的实例。用户通常不会接触这个事件。特别的,因为协议解释器绑定它的方式,socket
将不会触发readable
事件。这个socket
可以由request.connection
得到。
Event: 'close'
function () { }
当服务器关闭时触发。
Event: 'checkContinue'
function (request, response) { }
当每次收到一个HTTPExpect: 100-continue
请求时触发。如果不监听这个事件,那么服务器会酌情自动响应一个100 Continue
。
处理该事件时,如果客户端可以继续发送请求主体则调用response.writeContinue()
, 如果不能则生成合适的HTTP响应(如400 Bad Request
)。
注意,当这个事件被触发并且被处理,request
事件则不会再触发。
Event: 'connect'
function (request, socket, head) { }
每当客户端发起一个httpCONNECT
请求时触发。如果这个事件没有被监听,那么客户端发起httpCONNECT
的连接会被关闭。
request
是一个http请求参数,它也被包含在request
事件中。
socket
是一个服务器和客户端间的网络套接字。
head
是一个Buffer
实例,隧道流中的第一个报文,该参数可能为空
在这个事件被触发后,请求的socket
将不会有data
事件的监听器,意味着你将要绑定一个data
事件的监听器来处理这个socket
中发往服务器的数据。
Event: 'upgrade'
function (request, socket, head) { }
每当客户端发起一个httpupgrade
请求时触发。如果这个事件没有被监听,那么客户端发起upgrade
的连接会被关闭。
request
是一个http请求参数,它也被包含在request
事件中。
socket
是一个服务器和客户端间的网络套接字。
head
是一个Buffer
实例,升级后流中的第一个报文,该参数可能为空
在这个事件被触发后,请求的socket
将不会有data
事件的监听器,意味着你将要绑定一个data
事件的监听器来处理这个socket
中发往服务器的数据。
Event: 'clientError'
function (exception, socket) { }
如果一个客户端连接发生了错误,这个事件将会被触发。
socket
是一个错误来源的net.Socket
对象。
server.listen(port[, hostname][, backlog][, callback])
从指定的端口和主机名开始接收连接。如果hostname
被忽略,那么如果IPv6可用,服务器将接受任意IPv6地址(::),否则为任何IPv4地址(0.0.0.)。port
为0
将会设置一个随机端口。
如果要监听一个unix socket
,请提供一个文件名而不是端口和主机名。
backlog
是连接等待队列的最大长度。它的实际长度将有你操作系统的sysctl
设置(如linux中的tcp_max_syn_backlog
和somaxconn
)决定。默认值为511
(不是512
)。
这个函数式异步的。最后一个callback
参数将会添加至listening
事件的监听器。参阅net.Server.listen(port)
。
server.listen(path[, callback])
通过给定的path
,开启一个监听连接的 UNIX socket
服务器。
这个函数式异步的。最后一个callback
参数将会添加至listening
事件的监听器。参阅net.Server.listen(path)
。
server.listen(handle[, callback])
handle Object
callback Function
handle
对象是既可以是一个server可以是一个socket
(或者任意以下划线开头的成员_handle
),或一个{fd: <n>}
对象。
这将使得服务器使用指定句柄接受连接,但它假设文件描述符或句柄已经被绑定至指定的端口或域名socket
。
在Windows下不支持监听一个文件描述符。
这个函数式异步的。最后一个callback
参数将会添加至listening
事件的监听器。参阅net.Server.listen()
。
server.close([callback])
让服务器停止接收新的连接。参阅net.Server.close()
。
限制最大请求头数量,默认为1000
。如果设置为0
,则代表无限制。
server.setTimeout(msecs, callback)
msecs Number
callback Function
设置socket
的超时值,并且如果超时,会在服务器对象上触发一个timeout
事件,并且将传递socket
作为参数。
如果在服务器对象时又一个timeout
事件监听器,那么它将会被调用,而超时的socket
将会被作为参数。
默认的,服务器的超时值是两分钟,并且如果超时,socket
会被自动销毁。但是,如果你给timeout
事件传递了回调函数,那么你必须为要亲自处理socket
超时。
返回一个server
对象。
server.timeout
Number 默认为120000
(两分钟)
一个socket
被判定为超时之前的毫秒数。
注意,socket
的超时逻辑在连接时被设定,所以改变它的值仅影响之后到达服务器的连接,而不是所有的连接。
设置为0
将会为连接禁用所有的自动超时行为。
Class: http.ServerResponse
这个对象由HTTP服务器内部创建,而不是由用户。它会被传递给request
事件监听器的第二个参数。
这个对象实现了Writable
流接口。它是一个具有以下事件的EventEmitter
:
Event: 'close'
function () { }
表明底层的连接在response.end()
被调用或能够冲刷前被关闭。
Event: 'finish'
function () { }
当响应被设置时触发。更明确地说,这个事件在当响应头的最后一段和响应体为了网络传输而交给操作系统时触发。它并不表明客户端已经收到了任何信息。
这个事件之后,response
对象不会再触发任何事件。
response.writeContinue()
给客户端传递一个HTTP/1.1 100 Continue
信息,表明请求体必须被传递。参阅服务器的checkContinue
事件。
为请求设置一个响应头。statusCode
是一个三位的HTTP状态码,如404
。最后一个参数headers
,是响应头。第二个参数statusMessage
是可选的,表示状态码的一个可读信息。
var body = 'hello world';
response.writeHead(200, {
'Content-Length': body.length,
'Content-Type': 'text/plain' });
这个方法对于一个信息只能调用一次,并且它必须在response.end()
之前被调用。
如果你在调用这个方法前调用了response.write()
或response.end()
,将会调用这个函数,并且一个implicit/mutable
头会被计算使用。
注意,Content-Length
是以字节计,而不是以字符计。上面例子能正常运行时因为字符串'hello world'
仅包含单字节字符。如果响应体包含了多字节编码的字符,那么必须通过指定的编码来调用Buffer.byteLength()
来确定字节数。并且node.js
不会检查Content-Length
与响应体的字节数是否相等。
response.setTimeout(msecs, callback)
msecs Number
callback Function
设置socket
的超时值(毫秒),如果传递了回调函数,那么它将被添加至response
对象的timeout
事件的监听器。
如果没有为request
,request
或服务器添加timeout
监听器。那么socket
会在超时时销毁。如果你为request
,request
或服务器添加了timeout
监听器,那么你必须为要亲自处理socket
超时。
返回一个response
对象。
response.statusCode
当使用隐式响应头(不明确调用response.writeHead()
)时,这个属性控制了发送给客户端的状态码,在当响应头被冲刷时。
response.statusCode = 404;
在响应头发送给客户端之后,这个属性表明了被发送的状态码。
response.statusMessage
当使用隐式响应头(不明确调用response.writeHead()
)时,这个属性控制了发送给客户端的状态信息,在当响应头被冲刷时。当它没有被指定(undefined
)时,将会使用标准HTTP状态码信息。
response.statusMessage = 'Not found';
在响应头发送给客户端之后,这个属性表明了被发送的状态信息。
为一个隐式的响应头设置一个单独的头内容。如果这个头已存在,那么将会被覆盖。当你需要发送一个同名多值的头内容时请使用一个字符串数组。
response.setHeader("Content-Type", "text/html");
response.setHeader("Set-Cookie", ["type=ninja", "language=javascript"]);
布尔值(只读)。如果响应头被发送则为true
,反之为false
。
response.sendDate
当为true
时,当响应头中没有Date
值时会被自动设置。默认为true
。
这个值只会为了测试目的才会被禁用。HTTP协议要求响应头中有Date
值。
读取已经被排队但还未发送给客户端的响应头。注意name
是大小写敏感的。这个函数只能在响应头被隐式冲刷前被调用。
var contentType = response.getHeader('content-type');
取消一个在队列中等待隐式发送的头。
response.removeHeader("Content-Encoding");
response.write(chunk[, encoding][, callback])
如果这个方法被调用并且response.writeHead()
没有备调用,那么它将转换到隐式响应头模式,并且刷新隐式响应头。
这个方法传递一个数据块的响应体。这个方法可能被调用多次来保证连续的提供响应体。
数据块可以是一个字符串或一个buffer
。如果数据块是一个字符串,那么第二个参数是它的编码。默认是UTF-8.最后一个回调函数参数会在数据块被冲刷后触发。
注意:这是一个底层的HTTP报文,高级的多部分报文编码无法使用。
第一次调用response.write()
时,它会传递缓存的头信息以及第一个报文给客户端。第二次调用时,node.js
假设你将发送数据流,然后分别发送。这意味着响应式缓冲到第一个报文的数据块中。
如果整个数据都成功得冲刷至内核缓冲,则放回true
。如果用户内存中有部分或全部的数据在队列中,那么返回false
。drain
事件将会在缓冲再次释放时触发。
这个方法添加HTTP尾随头(一个在消息最后的头)给响应。
只有当数据编码被用于响应时尾随才会触发。如果不是(如请求是HTTP/1.0
),它们将被安静地丢弃。
注意,如果你要触发尾随消息,HTTP要求传递一个包含报文头场列表的尾随头:
response.writeHead(200, { 'Content-Type': 'text/plain',
'Trailer': 'Content-MD5' });
response.write(fileData);
response.addTrailers({'Content-MD5': "7895bf4b8828b55ceaf47747b4bca667"});
response.end();
response.end([data][, encoding][, callback])
这个方法告知服务器所有的响应头和响应体都已经发送;服务器会认为这个消息完成了。这个方法必须在每次响应完成后被调用。
如果指定了data
,就相当于调用了response.write(data, encoding)
之后再调用response.end(callback)
。
如果指定了回调函数,那么它将在响应流结束后触发。
http.request(options[, callback])
node.js
为每个服务器维护了几个连接,用来产生HTTP请求。这函数允许你透明地发送请求。
options
参数可以是一个对象或一个字符串,如果options
是一个字符串,它将自动得被url.parse()
翻译。
Options:
host: 一个将要向其发送请求的服务器域名或IP地址。默认为localhost
。
hostname: host
的别名。为了支持url.parse()
的话,hostname
比host
更好些。
family: 解析host
和hostname
时的IP地址协议族。合法值是4
和6
。当没有指定时,将都被使用。
port: 远程服务器端口。默认为80
。
localAddress: 用于绑定网络连接的本地端口。
socketPath: Unix域socket
(使用host:port
或socketPath
)。
method: 指定HTTP请求方法的字符串。默认为GET
。
path: 请求路径。默认为/
。如果有查询字符串,则需要包含。例如'/index.html?page=12'。请求路径包含非法字符时抛出异常。目前,只否决空格,不过在未来可能改变。
headers: 一个包含请求头的对象。
auth: 用于计算认证头的基本认证,即'user:password'
。
agent: 控制agent
行为。当使用一个代理时,请求将默认为Connection: keep-alive
。可能值有:
- undefined (默认): 在这个主机和端口上使用全局`agent。
- Agent object: 在
agent
中显示使用passed。
- false: 跳出
agent
的连接池。默认请求为Connection: close
。
可选的回调函数将会被添加为response
事件的“一次性”监听器(one time listener)。
http.request()
返回一个http.ClientRequest
类的实例。这个ClientRequest
实例是一个可写流。如果你需要使用POST
请求上传一个文件,那么就将之写入这个ClientRequest
对象。
var postData = querystring.stringify({
'msg' : 'Hello World!'
var options = {
hostname: 'www.google.com',
port: 80,
path: '/upload',
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': postData.length
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);
res.on('end', function() {
console.log('No more data in response.')
req.on('error', function(e) {
console.log('problem with request: ' + e.message);
req.write(postData);
req.end();
注意,在例子中调用了req.end()
。使用http.request()
时必须调用req.end()
来表明你已经完成了请求(即使没有数据要被写入请求体)。
如果有一个错误在请求时发生(如DNS解析,TCP级别错误或实际的HTTP解析错误),一个error
事件将会在返回对象上触发。
下面有一些特殊的需要主要的请求头:
发送'Connection: keep-alive'
会告知node.js
保持连直到下一个请求发送。
发送'Content-length'
头会禁用默认的数据块编码。
发送'Expect'
头将会立刻发送一个请求头。通常,当发送'Expect: 100-continue'
时,你需要同时设置一个超时和监听后续的时间。参阅RFC2616的8.2.3章节来获取更多信息。
发送一个授权头将会覆盖使用auth
选项来进行基本授权。
http.get(options[, callback])
由于大多数请求是没有请求体的GET
请求。node.js
提供了这个简便的方法。这个方法和http.request()
方法的唯一区别是它设置请求方法为GET
且自动调用req.end()
。
http.get("http://www.google.com/index.html", function(res) {
console.log("Got response: " + res.statusCode);
}).on('error', function(e) {
console.log("Got error: " + e.message);
Class: http.Agent
HTTP Agent是用来把HTTP客户端请求中的socket
做成池。
HTTP Agent 也把客户端的请求默认为使用Connection:keep-alive
。如果没有HTTP请求正在等待成为空闲的套接字的话,那么套接字将关闭。这意味着node.js
的资源池在负载的情况下对keep-alive
有利,但是仍然不需要开发人员使用KeepAlive来手动关闭HTTP客户端。
如果你选择使用HTTP KeepAlive
,那么你可以创建一个标志设为true
的Agent对象(见下面的构造函数选项)。然后,Agent将会在资源池中保持未被使用的套接字,用于未来使用。它们将会被显式标记,以便于不保持node.js
进程的运行。但是当KeepAlive agent没有被使用时,显式地destroy()
KeepAlive agent仍然是个好主意,这样socket
会被关闭。
当socket
触发了close
事件或者特殊的agentRemove
事件的时候,套接字们从agent的资源池中移除。这意味着如果你打算保持一个HTTP请求长时间开启,并且不希望它保持在资源池中,那么你可以按照下列几行的代码做事:
http.get(options, function(res) {
}).on("socket", function (socket) {
socket.emit("agentRemove");
另外,你可以使用agent:false
来停用池:
http.get({
hostname: 'localhost',
port: 80,
path: '/',
agent: false
}, function (res) {
new Agent([options])#
options Object 为agent设置可配置的选项。可以有以下属性:
keepAlive Boolean 在未来保持池中的socket
被其他请求所使用,默认为false
keepAliveMsecs Integer 当使用HTTP KeepAlive时,通过被保持连接的socket
发送TCP KeepAlive 报文的间隔。默认为1000
。只在KeepAlive
被设置为true
时有效
maxSockets Number 每个主机允许拥有的socket
的最大数量。默认为Infinity
maxFreeSockets Number 在空闲状态下允许打开的最大socket
数。仅在keepAlive
为true
时有效。默认为256
http.request
使用的默认的http.globalAgent
包含它们属性的各自的默认值。
为了配置它们中的任何一个,你必须创建你自己的Agent
对象。
var http = require('http');
var keepAliveAgent = new http.Agent({ keepAlive: true });
options.agent = keepAliveAgent;
http.request(options, onResponseCallback);
agent.maxSockets
默认为Infinity
。决定了每个源上可以拥有的并发的socket
的数量。源为'host:port'
或'host:port:localAddress'
结合体。
agent.maxFreeSockets
默认为256
。对于支持HTTP KeepAlive的Agent,这设置了在空闲状态下保持打开的最大socket
数量。
agent.sockets
这个对象包含了正在被Agent使用desocket
数组。请不要修改它。
agent.freeSockets
这个对象包含了当HTTP KeepAlive被使用时正在等待的socket
数组。请不要修改它。
agent.requests
这个对象包含了还没有被分配给socket
的请求队列。请不要修改它。
agent.destroy()
销毁正在被agent使用的所有socket
。
通常没有必要这么做。但是,如果你正在使用一个启用了KeepAlive
的agent,那么最好明确地关闭agent当你知道它不会再被使用时。否则,在服务器关闭它们前socket
可能被闲置。
agent.getName(options)
通过一个请求选项集合来获取一个独一无二的名字,来决定一个连接是否可被再使用。在http代理中,这返回host:port:localAddress
。在https代理中,name
包括了CA,cert,ciphers和HTTPS/TLS-specific
配置来决定一个socket
是否能被再使用。
http.globalAgent
所有的http客户端请求使用的默认全局Agent
实例。
Class: http.ClientRequest
这个对象时被内部创建的,并且通过http.request()
被返回。它代表了一个正在处理的请求,其头部已经进入了队列。这个头部仍然可以通过setHeader(name, value)
,getHeader(name)
和removeHeader(name)
修改。实际的头部会随着第一个数据块发送,或在关闭连接时发送。
要获得响应对象,请为response
事件添加一个监听器。request
对象的response
事件将会在收到响应头时触发。这个response
事件的第一个参数是一个http.IncomingMessage
的实例。
在response
事件期间,可以给响应对象添加监听器;尤其是监听data
事件。
如果没有添加response
事件监听器,那么响应会被完全忽略。但是,如果你添加了response
事件,那么你必须通过调用response.read()
,添加data
事件监听器或调用.resume()
方法等等,来从响应对象中消耗数据。在数据被消费之前,end
事件不会触发。如果数据没有被读取,它会消耗内存,最后导致'process out of memory'
错误。
注意:node.js
不会检查Content-Length
和被传输的响应体长度是否相同。
这个请求实现了Writable
流接口。这是一个包含了以下事件的EventEmitter
:
Event: 'response'
function (response) { }
当这个请求收到一个响应时触发。这个事件只会被触发一次。response
参数是一个http.IncomingMessage
实例。
Options:
- host: 一个向其发送请求的服务器的域名或IP地址
- port: 远程服务器的端口
- socketPath: Unix域
socket
(使用host:port
或socketPath
中的一个)
Event: 'socket'
- function (socket) { }
当一个socket
被分配给一个请求时触发。
Event: 'connect'
- function (response, socket, head) { }
每次服务器使用CONNECT
方法响应一个请求时触发。如果这个事件没有被监听,那么接受CONNECT
方法的客户端将会关闭它们的连接。
以下是一对客户端/服务器代码,展示如何监听connect
事件。
var http = require('http');
var net = require('net');
var url = require('url');
var proxy = http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('okay');
proxy.on('connect', function(req, cltSocket, head) {
var srvUrl = url.parse('http://' + req.url);
var srvSocket = net.connect(srvUrl.port, srvUrl.hostname, function() {
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', function() {
var options = {
port: 1337,
hostname: '127.0.0.1',
method: 'CONNECT',
path: 'www.google.com:80'
var req = http.request(options);
req.end();
req.on('connect', function(res, socket, head) {
console.log('got connected!');
socket.write('GET / HTTP/1.1\r\n' +
'Host: www.google.com:80\r\n' +
'Connection: close\r\n' +
'\r\n');
socket.on('data', function(chunk) {
console.log(chunk.toString());
socket.on('end', function() {
proxy.close();
Event: 'upgrade'
function (response, socket, head) { }
Emitted each time a server responds to a request with an upgrade. If this event isn't being listened for, clients receiving an upgrade header will have their connections closed.
每次服务器返回upgrade
响应给请求时触发。如果这个事件没有被监听,客户端接收一个upgrade
头时会关闭它们的连接。
以下是一对客户端/服务器代码,展示如何监听upgrade
事件。
var http = require('http');
var srv = http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('okay');
srv.on('upgrade', function(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', function() {
var options = {
port: 1337,
hostname: '127.0.0.1',
headers: {
'Connection': 'Upgrade',
'Upgrade': 'websocket'
var req = http.request(options);
req.end();
req.on('upgrade', function(res, socket, upgradeHead) {
console.log('got upgraded!');
socket.end();
process.exit(0);
Event: 'continue'
function () { }
当服务器发出一个'100 Continue'
HTTP响应时,通常这是因为请求包含'Expect: 100-continue'
。这是一个客户端须要发送请求体的指示。
Event: 'abort'
function () { }
当请求被客户端中止时触发。这个事件只会在第一次调用abort()
时触发。
冲刷请求头。
由于效率原因,node.js
通常在直到你调用request.end()
或写入第一个数据块前都会缓冲请求头,然后努力将请求头和数据打包为一个TCP报文。
这通常是你想要的(它节约了一个TCP往返)。但当第一份数据会等待很久才被发送时不是。request.flushHeaders()
使你能绕过这个优化并且启动请求。
request.write(chunk[, encoding][, callback])
发送一个响应块。当用户想要将请求体流式得发送给服务器时,可以通过调用这个方法多次来办到--在这种情况下,建议在创建请求时使用['Transfer-Encoding', 'chunked']
头。
chunk
参数必须是一个Buffer
或一个字符串。
encoding
参数是可选的,并且仅当chunk
是字符串时有效。默认为'utf8'
。
callback
参数是可选的,并且当数据块被冲刷时被调用。
request.end([data][, encoding][, callback])
结束发送请求。如果有任何部分的请求体未被发送,这个函数将会将它们冲刷至流中。如果请求是成块的,它会发送终结符'0\r\n\r\n'
。
如果data
被指定,那么这与调用request.write(data, encoding)
后再调用request.end(callback)
相同。
如果callback
被指定,那么它将在请求流结束时被调用。
request.abort()
中止请求。
request.setTimeout(timeout[, callback])
一旦一个socket
被分配给这个请求并且完成连接,socket.setTimeout()
会被调用。
返回request
对象。
request.setNoDelay([noDelay])
一旦一个socket
被分配给这个请求并且完成连接,socket.setNoDelay()
会被调用。
request.setSocketKeepAlive([enable][, initialDelay])
一旦一个socket
被分配给这个请求并且完成连接,socket.setKeepAlive()
会被调用。
http.IncomingMessage
一个IncomingMessage
对象被http.Server
或http.ClientRequest
创建,并且分别被传递给request
和response
事件的第一个参数。它被用来取得响应状态,响应头和响应体。
它实现了Readable
流接口,并且有以下额外的事件,方法和属性。
Event: 'close'
function () { }
表明底层连接被关闭。与end
相同,这个时间每次响应只会触发一次。
message.httpVersion
当向服务器发送请求时,客户端发送的HTTP版本。向客户端发送响应时,服务器响应的HTTP版本。通常是'1.1'
或'1.0'
。
另外,response.httpVersionMajor
是第一个整数,response.httpVersionMinor
是第二个整数。
请求/响应头对象。
只读的头名称和值映射。头名称是小写的,例子:
console.log(request.headers);
接受到的原始请求/响应头列表。
注意键和值在同一个列表中,它并非一个元组列表。于是,偶数偏移量为键,奇数偏移量为对应的值。
头名称不是必须小写的,并且重复也没有被合并。
console.log(request.rawHeaders);
message.trailers
请求/响应尾部对象。只在end
事件中存在。
message.rawTrailers
接受到的原始请求/响应头尾部键值对。只在end
事件中存在。
message.setTimeout(msecs, callback)
msecs Number
callback Function
调用message.connection.setTimeout(msecs, callback)
。
返回message
。
message.method
仅对从http.Server
获得的请求有效。
请求方法是字符串。只读。例如:'GET'
,'DELETE'
。
message.url
仅对从http.Server
获得的请求有效。
请求的URL字符串。这仅仅只包含实际HTTP请求中的URL。如果请求是:
GET /status?name=ryan HTTP/1.1\r\n
Accept: text/plain\r\n
那么request.url
将是:
'/status?name=ryan'
如果你想分块地解释URL。你可以调用require('url').parse(request.url)
。例子:
iojs> require('url').parse('/status?name=ryan')
{ href: '/status?name=ryan',
search: '?name=ryan',
query: 'name=ryan',
pathname: '/status' }
如果你想从查询字符串中提取参数,你可以使用require('querystring').parse
函数,或者给require('url').parse
方法的第二个参数传递true
,例子:
iojs> require('url').parse('/status?name=ryan', true)
{ href: '/status?name=ryan',
search: '?name=ryan',
query: { name: 'ryan' },
pathname: '/status' }
message.statusCode
只对从http.ClientRequest
到来的响应有效。
3位整数HTTP状态码。如404
。
message.statusMessage
只对从http.ClientRequest
到来的响应有效。
HTTP响应状态信息。如OK
或Internal Server Error
。
message.socket
与此连接关联的net.Socket
对象。
通过HTTPS的支持,使用request.socket.getPeerCertificate()
来获取客户端的身份细节。