HTTP

穩定性: 3 - 穩定

使用 HTTP 服務器或客戶端功能必須調用 require('http')。

Node 里的 HTTP 接口支持協議里原本比較難用的特性。特別是很大的或塊編碼的消息。這些接口不會完全緩存整個請求或響應，這樣用戶可以在請求或響應中使用數據流。

HTTP消息頭對象和下面的例子類似：

{ 'content-length': '123',
  'content-type': 'text/plain',
  'connection': 'keep-alive',
  'host': 'mysite.com',
  'accept': '*/*' }

Keys 都是小寫，值不能修改。

為了能支持盡可能多的 HTTP 應用程序，Node 提供的 HTTP API 接口都是底層的。僅能處理流和消息。它把消息解析成報文頭和報文體，但是不解析實際的報文頭和報文體內容。

定義報文頭的時候，多個值間可用 , 分隔。除了 set-cookie 和 cookie 頭，因為它們表示值的數組。諸如 content-length 的只有一個值的報文頭，直接解析，并且只有單值可以表示成已經解析好的對象。

接收到的原始頭信息以數組（[key, value, key2, value2, ...]）的形式保存在 rawHeaders 里。例如，之前提到的消息對象會有如下的 rawHeaders：

[ '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 。

類： http.Server

這是事件分發器 EventEmitter，有以下事件：

事件： 'request'

function (request, response) { }

每當有請求的時候觸發。注意：每個連接可以有多個請求（在 keep-alive 連接中）。request 是 http.IncomingMessage 實例，response 是 http.ServerResponse 的實例。

事件： 'connection'

function (socket) { }

當建立新的 TCP 流的時候。 socket 是一個 net.Socket 對象。通常用戶不會訪問這個事件。協議解析器綁定套接字時采用的方式使套接字不會出發 readable 事件。也能通過 request.connection 訪問 socket。

事件： 'close'

function () { }

服務器關閉的時候觸發。

事件： 'checkContinue'

function (request, response) { }

當 http 收到 100-continue 的 http 請求時會觸發。如果沒有監聽這個事件，服務器將會自動發送 100 Continue 的響應。

如果客戶端需要繼續發送請求主題，或者生成合適的 HTTP 響應（如，400 請求無效），可以通過調用 response.writeContinue() 來處理。

注意：觸發并處理這個事件的時候，不會再觸發 request 事件。

事件： 'connect'

function (request, socket, head) { }

當客戶端請求 http 連接時觸發。如果沒有監聽這個事件，客戶端請求連接的時候會被關閉。

• request 是 http 請求的參數，與 request 事件參數相同。
• socket 是服務器和客戶端間的 socket。
• head 是 buffer 的實例。網絡隧道的第一個包，可能為空。

這個事件觸發后，請求的 socket 不會有 data 事件監聽器，也就是說你需要綁定一個監聽器到 data 上，來處理在發送到服務器上的 socket 數據。

事件： 'upgrade'

function (request, socket, head) { }

當客戶端請求 http upgrage 時候會觸發。如果沒有監聽這個事件，客戶端請求一個連接的時候會被關閉。

• request 是 http 請求的參數，與 request 事件參數相同。
• socket 是服務器和客戶端間的 socket。
• head 是 buffer 的實例。網絡隧道的第一個包，可能為空。

這個事件觸發后，請求的 socket 不會有 data 事件監聽器，也就是說你需要綁定一個監聽器到 data 上，來處理在發送到服務器上的 socket 數據。

事件： 'clientError'

function (exception, socket) { }

如果一個客戶端連接觸發了一個 'error' 事件, 它就會轉發到這里.

socket 是導致錯誤的 net.Socket 對象。

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

在指定的的端口和主機名上開始接收連接。 如果忽略主機名，服務器將會接收指向任意 IPv4 的地址(INADDR_ANY)。

監聽一個 unix socket，需要提供一個文件名而不是主機名和端口。

積壓量 backlog 為等待連接隊列的最大長度。實際的長度由你的操作系統的 sysctl 設置決定（比如 linux 上的 tcp_max_syn_backlog and somaxconn）。默認參數值為 511 (不是 512)

這是異步函數。最后一個參數 callback 會作為事件監聽器添加到 listening 事件。參見net.Server.listen(port)。

server.listen(path[, callback])

啟動一個 UNIX socket 服務器所給路徑 path

這是異步函數。最后一個參數 callback 會作為事件監聽器添加到 listening事件。參見net.Server.listen(port)。

server.listen(handle[, callback])

• handle {Object}

• callback {Function}

  handle 對象可以是 server 或 socket（任意以下劃線 _handle開頭的成員），或者{fd: <n>}對象。

這會導致 server 用參數 handle 接收連接，前提條件是文件描述符或句柄已經連接到端口或域 socket。

Windows 不能監聽文件句柄。

這是異步函數。最后一個參數 callback 會作為事件監聽器添加到 listening 事件。參見net.Server.listen(port)。

server.close([callback])

禁止 server 接收連接。參見 net.Server.close().

server.maxHeadersCount

最大請求頭的數量限制，默認 1000。如果設置為 0，則不做任何限制。

server.setTimeout(msecs, callback)

• msecs {Number}
• callback {Function}

為 socket 設置超時時間，單位為毫秒，如果發生超時，在 server 對象上觸發 'timeout' 事件，參數為 socket 。

如果在 Server 對象上有一個 'timeout' 事件監聽器，超時的時候，將會調用它，參數為 socket 。

默認情況下，Server 的超時為 2 分鐘，如果超時將會銷毀 socket。如果你給 Server 的超時事件設置了回調函數，那你就得負責處理 socket 超時。

server.timeout

• {Number} Default = 120000 (2 minutes)

超時的時長，單位為毫秒。

注意，socket 的超時邏輯在連接時設定，所以有新的連接時才能改變這個值。

設為 0 時，建立連接的自動超時將失效。

類： http.ServerResponse

這是一個由 HTTP 服務器（而不是用戶）內部創建的對象。作為第二個參數傳遞給 'request'事件。

該響應實現了 Writable Stream 接口。這是一個包含下列事件的 EventEmitter ：

事件： 'close'

function () { }

在調用 response.end()，或準備 flush 前，底層連接結束。

事件： 'finish'

function () { }

發送完響應觸發。響應頭和響應體最后一段數據被剝離給操作系統后，通過網絡來傳輸時被觸發。這并不代表客戶端已經收到數據。

這個事件之后，響應對象不會再觸發任何事件。

response.writeContinue()

發送 HTTP/1.1 100 Continue 消息給客戶端，表示請求體可以發送。可以在服務器上查看'checkContinue' 事件。

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

發送一個響應頭給請求。狀態碼是 3 位數字，如 404。最后一個參數 headers 是響應頭。建議第二個參數設置為可以看的懂的消息。

例如:

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

這個方法僅能在消息中調用一次，而且必須在 response.end() 前調用。

如果你在這之前調用 response.write() 或 response.end(),將會計算出不穩定的頭。

Content-Length 是字節數，而不是字符數。上面的例子 'hello world' 僅包含一個字節字符。如果 body 包含高級編碼的字符， Buffer.byteLength() 就必須確定指定編碼的字符數。Node 不會檢查Content-Length 和 body 的長度是否相同。

response.setTimeout(msecs, callback)

• msecs {Number}
• callback {Function}

設置 socket 超時時間，單位為毫秒。如果提供了回調函數，將會在 response 對象的 'timeout' 事件上添加監聽器。

如果沒有給請求、響應、服務器添加 'timeout' 監視器，超時的時候將會銷毀 socket。如果你給請求、響應、服務器加了處理函數，就需要負責處理 socket 超時。

response.statusCode

使用默認的 headers 時（沒有顯式的調用 response.writeHead() ），這個屬性表示將要發送給客戶端狀態碼。

例如:

response.statusCode = 404;

響應頭發送給客戶端的后，這個屬性表示狀態碼已經發送。

response.statusMessage

使用默認 headers 時（沒有顯式的調用 response.writeHead() ）, 這個屬性表示將要發送給客戶端狀態信息。 如果這個沒有定義，將會使用狀態碼的標準消息。

例如:

response.statusMessage = 'Not found';

當響應頭發送給客戶端的時候，這個屬性表示狀態消息已經發送。

response.setHeader(name, value)

設置默認頭某個字段內容。如果這個頭即將被發送，內容會被替換。如果你想設置更多的頭， 就使用一個相同名字的字符串數組。

例如:

response.setHeader("Content-Type", "text/html");

或

response.setHeader("Set-Cookie", ["type=ninja", "language=javascript"]);

response.headersSent

Boolean (只讀)。如果headers發送完畢,則為 true,反之為 false。

response.sendDate

默認值為 true。若為 true,當 headers 里沒有 Date 值時，自動生成 Date 并發送。

只有在測試環境才能禁用; 因為 HTTP 要求響應包含 Date 頭.

response.getHeader(name)

讀取一個在隊列中但是還沒有被發送至客戶端的header。名字是大小寫敏感。僅能再頭被flushed前調用。

例如:

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

response.removeHeader(name)

從即將發送的隊列里移除頭。

例如:

response.removeHeader("Content-Encoding");

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

如果調用了這個方法，且還沒有調用 response.writeHead()，將會切換到默認的 header，并更新這個header。

這個方法將發送響應體數據塊。可能會多次調用這個方法，以提供 body 成功的部分內容。

chunk 可以是字符串或 buffer。如果 chunk 是字符串，第二個參數表明如何將它編碼成字節 流。encoding 的默認值是'utf8'。最后一個參數在刷新這個數據塊時調用。

注意：這個是原始的 HTTP body，和高級的multi-part body 編碼無關。

第一次調用 response.write() 的時候，將會發送緩存的頭信息和第一個 body 給客戶端。第二次，將會調用 response.write()。Node 認為你將會獨立發送流數據。這意味著，響應緩存在第一個數據塊中。

如果成功的刷新全部數據到內核緩沖區，返回 true 。如果部分或全部數據在用戶內存中還處于排隊狀況，返回 false 。當緩存再次釋放的時候，將會觸發 'drain'。

response.addTrailers(headers)

這個方法給響應添加 HTTP 的尾部 header（消息末尾的 header）。

只有數據塊編碼用于響應體時，才會觸發 Trailers；如果不是（例如，請求是HTTP/1.0），它們將會被自動丟棄。

如果你想觸發 trailers， HTTP 會要求發送 Trailer 頭，它包含一些信息，比如：

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

這個方法告訴服務器，所有的響應頭和響應體已經發送；服務器可以認為消息結束。response.end() 方法必須在每個響應中調用。

如果指定了參數 data，將會在響應流結束的時候調用。

http.request(options[, callback])

Node 維護每個服務器的連接來生成 HTTP 請求。這個函數讓你可以發布請求。

參數options是對象或字符串。如果 options 是字符串，會通過 url.parse() 自動解析。

options 值:

• host: 請求的服務器域名或 IP 地址，默認：'localhost'
• hostname: 用于支持 url.parse()。 hostname 優于 host
• port: 遠程服務器端口。 默認： 80.
• localAddress: 用于綁定網絡連接的本地接口
• socketPath: Unix域 socket（使用host:port或socketPath
• method: 指定 HTTP 請求方法。 默認： 'GET'.
• path: 請求路徑。 默認： '/'。如果有查詢字符串，則需要包含。例如'/index.html?page=12'。請求路徑包含非法字符時拋出異常。目前，只有空格不行，不過在未來可能改變。
• headers: 包含請求頭的對象
• auth: 用于計算認證頭的基本認證，即 user:password
• agent: 控制Agent的行為。當使用了一個Agent的時候，請求將默認為Connection: keep-alive。可能的值為：
  • undefined (default): 在這個主機和端口上使用 global Agent
  • Agent object: 在Agent中顯式使用 passed .
  • false: 選擇性停用連接池,默認請求為： Connection: close.
  • keepAlive: {Boolean} 持資源池周圍的socket，用于未來其它請求。默認值為false。
  • keepAliveMsecs: {Integer} 使用HTTP KeepAlive 的時候，通過正在保持活動的sockets發送TCP KeepAlive包的頻繁程度。默認值為1000。僅當keepAlive為true時才相關。

可選參數 callback 將會作為一次性的監視器，添加給 'response' 事件。

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

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

// write data to request body
req.write(postData);
req.end();

注意，例子里調用了 req.end()。http.request() 必須調用 req.end() 來表明請求已經完成，即使沒有數據寫入到請求 body 里。

如果在請求的時候遇到錯誤（DNS 解析、TCP 級別的錯誤或實際 HTTP 解析錯誤），在返回的請求對象時會觸發一個 'error' 事件。

有一些特殊的頭需要注意：

• 發送 Connection: keep-alive 告訴服務器保持連接，直到下一個請求到來。

• 發送 Content-length 頭將會禁用chunked編碼。

• 發送一個 Expect 頭，會立即發送請求頭，一般來說，發送 Expect: 100-continue ,你必須設置超時，并監聽 continue 事件。更多細節參見 RFC2616 Section 8.2.3 。

• 發送一個授權頭，將會使用 auth 參數重寫，來計算基本的授權。

http.get(options[, callback])

因為多數請求是沒有報文體的 GET 請求， Node 提供了這個簡便的方法。和 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);
});

類： http.Agent

HTTP Agent 用于 socket 池，用于 HTTP 客戶端請求。

HTTP Agent 也把客戶端請求默認為使用 Connection:keep-alive 。如果沒有 HTTP 請求正在等著成為空閑 socket 的話，那么 socket 將關閉。這意味著，Node 的資源池在負載的情況下對 keep-alive 有利，但是仍然不需要開發人員使用 KeepAlive 來手動關閉 HTTP 客戶端。

如果你選擇使用 HTTP KeepAlive， 可以創建一個 Agent 對象，將 flag 設置為 true. (參見下面的 constructor options ) ，這樣 Agent 會把沒用到的 socket 放到池里，以便將來使用。他們會被顯式的標志，讓 Node 不運行。但是，當不再使用它的時候，需要顯式的調用destroy()，這樣 socket 將會被關閉。

當 socket 事件觸發 close 事件或特殊的 agentRemove 事件時，socket 將會從 agent 池里移除。如果你要保持 HTTP 請求保持長時間打開，并且不希望他們在池里，可以參考以下代碼：

http.get(options, function(res) {
  // Do stuff
}).on("socket", function (socket) {
  socket.emit("agentRemove");
});

另外，你可以使用 agent:false 讓資源池停用：

http.get({
  hostname: 'localhost',
  port: 80,
  path: '/',
  agent: false  // create a new agent just for this one request
}, function (res) {
  // Do stuff with response
})

new Agent([options])

• options {Object} agent 上的設置選項集合，有以下字段內容:
  • keepAlive {Boolean} 持資源池周圍的 socket，用于未來其它請求。默認值為 false。
  • keepAliveMsecs {Integer} 使用 HTTP KeepAlive 的時候，通過正在保持活動的 sockets 發送 TCP KeepAlive 包的頻繁程度。默認值為 1000。僅當 keepAlive 為 true 時才相關。.】
  • maxSockets {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。決定了每臺主機上的 agent 可以擁有的并發 socket 的打開數量，主機可以是 host:port 或 host:port:localAddress。

agent.maxFreeSockets

默認值 256. 對于支持 HTTP KeepAlive 的 Agent 而言，這個方法設置了空閑狀態下仍然打開的套接字數的最大值。

agent.sockets

這個對象包含了當前 Agent 使用中的 socket 數組。不要修改它。

agent.freeSockets

使用 HTTP KeepAlive 的時候，這個對象包含等待當前 Agent 使用的 socket 數組。不要修改它。

agent.requests

這個對象包含了還沒分配給 socket 的請求數組。不要修改它。

agent.destroy()

銷毀任意一個被 agent 使用 的socket。

通常情況下不要這么做。如果你正在使用一個允許 KeepAlive 的 agent，當你知道不在使用它的時候，最好關閉 agent。否則，socket 會一直保存打開狀態，直到服務器關閉。

agent.getName(options)

獲取一組請求選項的唯一名，來確定某個連接是否可重用。在 http agent 里，它會返回 host:port:localAddress。在 http agent 里， name 包括 CA，cert, ciphers, 和其他 HTTPS/TLS 特殊選項來決定 socket 是否可以重用。

http.globalAgent

Agent 的全局實例，是 http 客戶端的默認請求。

類： http.ClientRequest

該對象在內部創建并從 http.request() 返回。他是 正在 處理的請求，其頭部已經在隊列中。使用 setHeader(name, value), getHeader(name), removeHeader(name) API 可以改變header。當關閉連接的時候，header將會和第一個數據塊一起發送。

為了獲取響應，可以給請求對象的 'response' 添加監聽器。當接收到響應頭的時候將會從請求對象里觸發'response'。'response' 事件執行時有一個參數，該參數為 http.IncomingMessage 的實例。

在 'response' 事件期間，可以給響應對象添加監視器，監聽 'data' 事件。

如果沒有添加 'response' 處理函數，響應將被完全忽略。如果你添加了 'response' 事件處理函數，那你 必須 消費掉從響應對象獲取的數據，可以在 'readable' 事件里調用 response.read() ，或者添加一個 'data' 處理函數，或者調用 .resume() 方法。如果未讀取數據，它將會消耗內存，最終產生 process out of memory 錯誤。

Node 不會檢查 Content-Length 和 body 的長度是否相同。

該請求實現了 Writable Stream 接口。這是一個包含下列事件的 EventEmitter。

事件： 'response'

function (response) { }

當接收到請求的時候會觸發，僅會觸發一次。 response 的參數是 http.IncomingMessage 的實例。

Options:

• host: 要請求的服務器域名或 IP 地址
• port: 遠程服務器的端口
• socketPath: Unix 域 Socket (使用 host:port 或 socketPath 之一)

事件： 'socket'

function (socket) { }

Socket 附加到這個請求的時候觸發。

事件： 'connect'

function (response, socket, head) { }

每次服務器使用 CONNECT 方法響應一個請求時觸發。如果這個這個事件未被監聽，接收 CONNECT 方法的客戶端將關閉他們的連接。

下面的例子展示了一對匹配的客戶端/服務器如何監聽 connect 事件。var http = require('http');var net = require('net');var url = require('url');

// Create an HTTP tunneling proxy
var proxy = http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('okay');
});
proxy.on('connect', function(req, cltSocket, head) {
  // connect to an origin server
  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-Proxy\r\n' +
                    '\r\n');
    srvSocket.write(head);
    srvSocket.pipe(cltSocket);
    cltSocket.pipe(srvSocket);
  });
});

// now that proxy is running
proxy.listen(1337, '127.0.0.1', function() {

  // make a request to a tunneling proxy
  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!');

    // make a request over an HTTP tunnel
    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();
    });
  });
});

事件： 'upgrade'

function (response, socket, head) { }

每當服務器響應 upgrade 請求時觸發。如果沒有監聽這個事件,客戶端會收到 upgrade 頭后關閉連接。

下面的例子展示了一對匹配的客戶端/服務器如何監聽 upgrade 事件。

var http = require('http');

// Create an HTTP server
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); // echo back
});

// now that server is running
srv.listen(1337, '127.0.0.1', function() {

  // make a request
  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);
  });
});

事件： 'continue'

function () { }

當服務器發送 '100 Continue' HTTP 響應的時候觸發，通常因為請求包含 'Expect: 100-continue'。該指令表示客戶端應發送請求體。

request.flushHeaders()

刷新請求的頭。

考慮效率因素，Node.js 通常會緩存請求的頭直到你調用 request.end()，或寫入請求的第一個數據塊。然后，包裝請求的頭和數據到一個獨立的 TCP 包里。

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

發送一個請求體的數據塊。通過多次調用這個函數，用戶能流式的發送請求給服務器，這種情況下，建議使用['Transfer-Encoding', 'chunked'] 頭。

chunk 參數必須是 Buffer 或字符串。

回調參數可選，當這個數據塊被刷新的時候會被調用。

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

發送請求完畢。如果 body 的數據沒被發送，將會將他們刷新到流里。如果請求是分塊的，該方法會發送終結符0\r\n\r\n 。

如果指定了 data，等同于先調用 request.write(data, encoding)，再調用 request.end(callback)。

如果有 callback，將會在請求流結束的時候調用。

request.abort()

終止一個請求. (v0.3.8 開始新加入)。

request.setTimeout(timeout[, callback])

如果 socket 被分配給這個請求，并完成連接，將會調用 socket.setTimeout() 。

request.setNoDelay([noDelay])

如果 socket 被分配給這個請求，并完成連接，將會調用 socket.setNoDelay()。

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

如果 socket 被分配給這個請求，并完成連接，將會調用 socket.setKeepAlive()。

http.IncomingMessage

http.Server 或 http.ClientRequest 創建了 IncomingMessage 對象，作為第一個參數傳遞給 'response'。它可以用來訪問應答的狀態，頭文件和數據。

它實現了 Readable Stream 接口，以及以下額外的事件，方法和屬性。

事件： 'close'

function () { }

表示底層連接已經關閉。和 'end'類似，這個事件每個應答只會發送一次。

message.httpVersion

客戶端向服務器發送請求時，客戶端發送的 HTTP 版本；或者服務器想客戶端返回應答時，服務器的 HTTP 版本。通常是 '1.1' 或 '1.0' 。

另外， response.httpVersionMajor 是第一個整數，response.httpVersionMinor 是第二個整數。

message.headers

請求/響應頭對象。

只讀的頭名稱和值的映射。頭的名字是小寫，比如：

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

message.rawHeaders

接收到的請求/響應頭字段列表。

注意，鍵和值在同一個列表中。它并非一個元組列表。所以，偶數偏移量為鍵，奇數偏移量為對應的值。

頭名字不是小寫敏感，也沒用合并重復的頭。// Prints something like://// [ '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.trailers

請求/響應 的尾部對象。只在 'end' 事件中存在。

message.rawTrailers

接收到的原始的請求/響應尾部鍵和值。僅在 'end' 事件中存在。

message.setTimeout(msecs, callback)

• msecs {Number}
• callback {Function}

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

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
\r\n

request.url 就是:

'/status?name=ryan'

如果你想將 URL 分解，可以用 require('url').parse(request.url)，例如：

node> require('url').parse('/status?name=ryan')
{ href: '/status?name=ryan',
  search: '?name=ryan',
  query: 'name=ryan',
  pathname: '/status' }

如果想從查詢字符串中解析出參數，可以用 require('querystring').parse 函數，或者將true 作為第二個參數傳遞給 require('url').parse。 例如：

node> 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.connection.verifyPeer() 和 request.connection.getPeerCertificate() 獲取客戶端的身份信息。