- 穩定的
要使用 HTTP 服務器與客戶端，需要 require('http')。
Node.js 中的 HTTP 接口被設計成支持協議的許多特性。 比如，大塊編碼的消息。 這些接口不緩沖完整的請求或響應，用戶能夠以流的形式處理數據。
HTTP 消息頭由一個對象表示，例如：
{ 'content-length': '123', 'content-type': 'text/plain', 'connection': 'keep-alive', 'host': 'mysite.com', 'accept': '*/*' } 鍵名是小寫的，鍵值不能修改。
為了支持各種可能的 HTTP 應用，Node.js 的 HTTP API 是非常底層的。 它只涉及流處理與消息解析。 它把一個消息解析成消息頭和消息主體，但不解析具體的消息頭或消息主體。
查看 message.headers 了解如何處理重復的消息頭。
接收到的原始消息頭保存在 rawHeaders 屬性中，它是一個 [key, value, key2, value2, ...] 數組。 例如，上面的消息頭對象有一個類似以下的 rawHeaders 列表：
[ 'ConTent-Length', '123456', 'content-LENGTH', '123', 'content-type', 'text/plain', 'CONNECTION', 'keep-alive', 'Host', 'mysite.com', 'accepT', '*/*' ] http.Agent 類
Agent 負責為 HTTP 客戶端管理連接的持續與復用。 它為一個給定的主機與端口維護着一個等待請求的隊列，且為每個請求重復使用一個單一的 socket 連接直到隊列為空，此時 socket 會被銷毀或被放入一個連接池中，在連接池中等待被有着相同主機與端口的請求再次使用。 是否被銷毀或被放入連接池取決於 keepAlive 選項。
連接池中的連接的 TCP Keep-Alive 是開啟的，但服務器仍然可能關閉閑置的連接，在這種情況下，這些連接會被移出連接池，且當一個新的 HTTP 請求被創建時再為指定的主機與端口創建一個新的連接。 服務器也可能拒絕允許同一連接上有多個請求，在這種情況下，連接會為每個請求重新創建，且不能被放入連接池。 Agent 仍然會創建請求到服務器，但每個請求會出現在一個新的連接。
但一個連接被客戶端或服務器關閉時，它會被移出連接池。 連接池中任何未被使用的 socket 會被釋放，從而使 Node.js 進程在沒有請求時不用保持運行。 （查看 socket.unref()）。
當 Agent 實例不再被使用時，建議 destroy() 它，因為未被使用的 socket 也會消耗操作系統資源。
當 socket 觸發 'close' 事件或 'agentRemove' 事件時，它會被移出代理池。 當打算長時間保持打開一個 HTTP 請求且不想它留着連接池中，則可以如下處理：
http.get(options, (res) => { // 處理事情 }).on('socket', (socket) => { socket.emit('agentRemove'); }); 代理也可被用於單獨的請求。 使用 {agent: false} 作為 http.get() 函數或 http.request() 函數的選項，則會為客戶端連接創建一個默認配置的一次性使用的 Agent。
agent:false:
http.get({ hostname: 'localhost', port: 80, path: '/', agent: false // 創建一個新的代理，只用於本次請求 }, (res) => { // 對響應進行處理 }); new Agent([options])
options<Object> 代理的配置選項。有以下字段：keepAlive<boolean> 保持 socket 可用即使沒有請求，以便它們可被將來的請求使用而無需重新建立一個 TCP 連接。默認為false。keepAliveMsecs<number> 當使用了keepAlive選項時，該選項指定 TCPKeep-Alive數據包的 初始延遲。 當keepAlive選項為false或undefined時，該選項無效。 默認為1000。maxSockets<number> 每個主機允許的最大 socket 數量。 默認為Infinity。maxFreeSockets<number> 在空閑狀態下允許打開的最大 socket 數量。 僅當keepAlive為true時才有效。 默認為256。
http.request() 使用的默認 http.globalAgent 的選項均為各自的默認值。
若要配置其中任何一個，則需要創建自定義的 http.Agent 實例。
const http = require('http'); const keepAliveAgent = new http.Agent({ keepAlive: true }); options.agent = keepAliveAgent; http.request(options, onResponseCallback); agent.createConnection(options[, callback])
options<Object> 包含連接詳情的選項。查看net.createConnection()了解選項的格式。callback<Function> 接收被創建的 socket 的回調函數。- 返回: <net.Socket>
創建一個用於 HTTP 請求的 socket 或流。
默認情況下，該函數類似於 net.createConnection()。 但是如果期望更大的靈活性，自定義的代理可以重寫該方法。
socket 或流可以通過以下兩種方式獲取：從該函數返回，或傳入 callback。
callback 有 (err, stream) 參數。
agent.keepSocketAlive(socket)
socket<net.Socket>
在 socket 被請求分離的時候調用, 可能被代理持續使用. 默認行為:
socket.unref(); socket.setKeepAlive(agent.keepAliveMsecs); 這個方法可以被一個特定的 Agent 子類重寫. 如果這個方法返回假值, socket 會被銷毀而不是 在下一次請求時持續使用.
agent.reuseSocket(socket, request)
socket<net.Socket>request<http.ClientRequest>
由於 keep-alive 選項被保持持久化, 在 socket 附加到 request 時調用. 默認行為是:
socket.ref(); 這個方法可以被一個特定的 Agent 子類重寫.
agent.destroy()
銷毀當前正被代理使用的任何 socket。
通常不需要這么做。 但是如果使用的代理啟用了 keepAlive，則當確定它不再被使用時，最好顯式地關閉代理。 否則，在服務器終止它們之前，socket 可能還會長時間保持打開。
agent.freeSockets
返回一個對象，包含當前正在等待被啟用了 keepAlive 的代理使用的 socket 數組。 不要修改該屬性。
agent.getName(options)
為請求選項的集合獲取一個唯一的名稱，用來判斷一個連接是否可以被復用。 對於 HTTP 代理，返回 host:port:localAddress。 對於 HTTPS 代理，名稱會包含 CA、證書、密碼、以及其他 HTTPS/TLS 特有的用於判斷 socket 復用性的選項。
agent.maxFreeSockets
默認為 256。 對於已啟用 keepAlive 的代理，該屬性可設置要保留的空閑 socket 的最大數量。
agent.maxSockets
默認為不限制。 該屬性可設置代理為每個來源打開的並發 socket 的最大數量。 來源是一個 'host:port' 或 'host:port:localAddress' 組合。
agent.requests
返回一個對象，包含還未被分配到 socket 的請求隊列。 不要修改。
agent.sockets#
返回一個對象，包含當前正被代理使用的 socket 數組。 不要修改。
http.ClientRequest 類#
該對象在 http.request() 內部被創建並返回。 它表示着一個正在處理的請求，其請求頭已進入隊列。 請求頭仍可使用 setHeader(name, value)、getHeader(name) 和 removeHeader(name) API 進行修改。 實際的請求頭會與第一個數據塊一起發送或當關閉連接時發送。
要獲取響應，需為 'response' 事件添加一個監聽器到請求對象上。 當響應頭被接收到時，'response' 事件會從請求對象上被觸發 。 'response' 事件被執行時帶有一個參數，該參數是一個 http.IncomingMessage 實例。
在 'response' 事件期間，可以添加監聽器到響應對象上，比如監聽 'data' 事件。
如果沒有添加 'response' 事件處理函數，則響應會被整個丟棄。 如果添加了 'response' 事件處理函數，則必須消耗完響應對象的數據，可通過調用 response.read()、或添加一個 'data' 事件處理函數、或調用 .resume() 方法。 數據被消耗完時會觸發 'end' 事件。 在數據被讀取完之前會消耗內存，可能會造成 'process out of memory' 錯誤。
注意：Node.js 不會檢查 Content-Length 與已傳輸的請求主體的長度是否相等。
該請求實現了 可寫流 接口。 它是一個包含以下事件的 EventEmitter：
'abort' 事件#
當請求已被客戶端終止時觸發。 該事件僅在首次調用 abort() 時觸發。
'aborted' 事件#
當請求已被服務器終止且網絡 socket 已關閉時觸發。
'connect' 事件#
response<http.IncomingMessage>socket<net.Socket>head<Buffer>
每當服務器響應 CONNECT 請求時觸發。 如果該事件未被監聽，則接收到 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('okay'); }); 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, hostname: '127.0.0.1', method: 'CONNECT', path: 'www.google.com:80' }; const req = http.request(options); req.end(); req.on('connect', (res, socket, head) => { console.log('已連接！'); // 通過代理服務器發送一個請求 socket.write('GET / HTTP/1.1\r\n' + 'Host: www.google.com:80\r\n' + 'Connection: close\r\n' + '\r\n'); socket.on('data', (chunk) => { console.log(chunk.toString()); }); socket.on('end', () => { proxy.close(); }); }); }); 'continue' 事件#
當服務器發送了一個 100 Continue 的 HTTP 響應時觸發，通常是因為請求包含 Expect: 100-continue。 這是客戶端將要發送請求主體的指令。
'response' 事件#
response<http.IncomingMessage>
當請求的響應被接收到時觸發。 該事件只觸發一次。
'socket' 事件#
socket<net.Socket>
當 socket 被分配到請求后觸發。
'upgrade' 事件#
response<http.IncomingMessage>socket<net.Socket>head<Buffer>
每當服務器響應 upgrade 請求時觸發。 如果該事件未被監聽，則接收到 upgrade 請求頭的客戶端會關閉連接。
例子，用一對客戶端和服務端來演示如何監聽 'upgrade' 事件：
const http = require('http'); // 創建一個 HTTP 服務器 const srv = http.createServer( (req, res) => { res.writeHead(200, { 'Content-Type': 'text/plain' }); res.end('okay'); }); 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, hostname: '127.0.0.1', headers: { 'Connection': 'Upgrade', 'Upgrade': 'websocket' } }; const req = http.request(options); req.end(); req.on('upgrade', (res, socket, upgradeHead) => { console.log('got upgraded!'); socket.end(); process.exit(0); }); }); request.abort()#
標記請求為終止。 調用該方法將使響應中剩余的數據被丟棄且 socket 被銷毀。
request.aborted#
如果請求已被終止，則該屬性的值為請求被終止的時間，從 1 January 1970 00:00:00 UTC 到現在的毫秒數。
request.connection#
See request.socket
request.end([data[, encoding]][, callback])#
data<string> | <Buffer>encoding<string>callback<Function>
結束發送請求。 如果部分請求主體還未被發送，則會刷新它們到流中。 如果請求是分塊的，則會發送終止字符 '0\r\n\r\n'。
如果指定了 data，則相當於調用 request.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])#
一旦 socket 被分配給請求且已連接，socket.setKeepAlive() 會被調用。
request.setTimeout(timeout[, callback])#
timeout<number> 請求被認為是超時的毫秒數。callback<Function> 可選的函數，當超時發生時被調用。等同於綁定到timeout事件。
一旦 socket 被分配給請求且已連接，socket.setTimeout() 會被調用。
返回 request。
request.socket#
引用底層socket。 通常用戶不想訪問此屬性。 特別地，由於協議解析器連接到socket的方式，socket將不會觸發'readable'事件。 在response.end()之后，該屬性為null。 也可以通過request.connection來訪問socket。
例如:
const http = require('http'); const server = http.createServer((req, res) => { const ip = req.socket.remoteAddress; const port = req.socket.remotePort; res.end(`你的IP地址是${ip}，你的源端口是${port}.`); }).listen(3000); request.write(chunk[, encoding][, callback])#
chunk<string> | <Buffer>encoding<string>callback<Function>
發送請求主體的一個數據塊。 通過多次調用該方法，一個請求主體可被發送到一個服務器，在這種情況下，當創建請求時，建議使用 ['Transfer-Encoding', 'chunked'] 請求頭。
encoding 參數是可選的，僅當 chunk 是一個字符串時才有效。默認為 'utf8'。
callback 參數是可選的，當數據塊被刷新時調用。
返回 request。
http.Server 類#
該類繼承自 net.Server，且具有以下額外的事件：
'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<Error>socket<net.Socket>
如果客戶端觸發了一個 'error' 事件，則它會被傳遞到這里。 該事件的監聽器負責關閉或銷毀底層的 socket。 例如，用戶可能希望更溫和地用 HTTP '400 Bad Request' 響應關閉 socket，而不是突然地切斷連接。
默認情況下，請求異常時會立即銷毀 socket。
socket 參數是發生錯誤的 net.Socket 對象。
const http = require('http'); const 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.IncomingMessage> HTTP 請求，同'request'事件。socket<net.Socket> 服務器與客戶端之間的網絡 socket。head<Buffer> 流的第一個數據包，可能為空。
每當客戶端發送 HTTP CONNECT 請求時觸發。 如果該事件未被監聽，則發送 CONNECT 請求的客戶端會關閉連接。
當該事件被觸發后，請求的 socket 上沒有 'data' 事件監聽器，這意味着需要綁定 'data' 事件監聽器，用來處理 socket 上被發送到服務器的數據。
'connection' 事件#
socket<net.Socket>
當一個新的 TCP 流被建立時觸發。 socket 是一個 net.Socket 類型的對象。 通常用戶無需訪問該事件。 注意，因為協議解析器綁定到 socket 的方式，socket 不會觸發 'readable' 事件。 socket 也可以通過 request.connection 訪問。
'request' 事件#
request<http.IncomingMessage>response<http.ServerResponse>
每次接收到一個請求時觸發。 注意，每個連接可能有多個請求（在 HTTP keep-alive 連接的情況下）。
'upgrade' 事件#
request<http.IncomingMessage> HTTP 請求，同'request'事件。socket<net.Socket> 服務器與客戶端之間的網絡 socket。head<Buffer> 流的第一個數據包，可能為空。
每當客戶端發送 HTTP upgrade 請求時觸發。 如果該事件未被監聽，則發送 upgrade 請求的客戶端會關閉連接。
當該事件被觸發后，請求的 socket 上沒有 'data' 事件監聽器，這意味着需要綁定 'data' 事件監聽器，用來處理 socket 上被發送到服務器的數據。
server.close([callback])#
callback<Function>
停止服務端接收新的連接。詳見 net.Server.close()。
server.listen(handle[, callback])#
handle<Object>callback<Function>
handle 對象可以被設為一個服務器或 socket（任何帶有一個 _handle 成員的對象）、或一個 {fd: <n>} 對象。
該函數可以讓服務器使用指定的處理程序接受連接，前提是文件描述符或處理程序已綁定了一個端口或域 socket。
Windows 平台上不支持監聽文件描述符。
該函數是異步的。 callback 會被添加到 'listening' 事件的監聽器中。也可查看 net.Server.listen()。
返回 server。
注意，server.listen() 方法可能被多次調用。 每次調用都會使用提供的選項重新打開服務器。
server.listen(path[, callback])#
path<string>callback<Function>
啟動一個 UNIX socket 服務器，並在給定的 path 上監聽連接。
該函數是異步的。 callback 會被添加到 'listening' 事件的監聽器中。也可查看 net.Server.listen(path)。
注意，server.listen() 方法可能被多次調用。 每次調用都會使用提供的選項重新打開服務器。
server.listen([port][, hostname][, backlog][, callback])#
port<number>hostname<string>backlog<number>callback<Function>
開始在指定的 port 和 hostname 上接受連接。 如果省略了 hostname，則當 IPv6 可用時，服務器會接受 未指定的 IPv6 地址（::）的連接，否則接受 未指定的 IPv4 地址（0.0.0.0）的連接。
請注意: 在大多數操作系統中，監聽未指定的IPv6地址unspecified IPv6 address (::)可能會導致net.Server也監聽未指定的IPv4地址unspecified IPv4 address (0.0.0.0)。
如果省略了 port 或值為 0，則操作系統會分配一個隨機的端口，該端口可在 'listening' 事件被觸發后使用 server.address().port 獲取。
若要監聽一個 UNIX socket，則需提供文件名而不是端口和主機名。
backlog 是等待連接的隊列的最大長度。 實際長度由操作系統通過 sysctl 設置決定，比如 Linux 上的 tcp_max_syn_backlog 和 somaxconn。 該參數的默認值是 511（不是 512）。
該函數是異步的。 callback 會被添加到 'listening' 事件的監聽器中。也可查看 net.Server.listen(port)。
注意，server.listen() 方法可能被多次調用。 每次調用都會使用提供的選項重新打開服務器。
server.listening#
返回一個布爾值，表示服務器是否正在監聽連接。
server.maxHeadersCount#
- <number> 默認為 2000。
限制請求頭的最大數量，默認為 2000。 如果設為 0，則沒有限制。
server.setTimeout([msecs][, callback])#
msecs<number> 默認為 120000 (2 分鍾)。callback<Function>
設置 socket 的超時時間。 如果發生超時，則觸發服務器對象的 'timeout' 事件，並傳入 socket 作為一個參數。
默認情況下，服務器的超時時間是 2 分鍾，且超時后的 socket 會被自動銷毀。 但是，如果你為服務器的 'timeout' 事件分配了一個回調函數，則超時必須被顯式地處理。
返回 server。
server.timeout#
- <number> 超時時間，以毫秒為單位。默認為 120000 (2 分鍾)。
socket 被認定為超時的空閑毫秒數。
值設為 0 可禁用請求連接的超時行為。
注意，socket 的超時邏輯是在連接上設定的，所以改變這個值只影響服務器新建的連接，而不會影響任何已存在的連接。
server.keepAliveTimeout#
- <number> 超時毫秒. 默認為 5000 (5秒).
服務器完成最后的響應之后需要等待的額外的傳入數據的活躍毫秒數, socket 才能被銷毀.
如果服務器在 keep-alive 計時已激活時接收到新的數據, 他會重置常規的非活動計時, 即server.timeout.
值為 0 時禁用傳入連接 keep-alive 的超時行為.
注意: scoket 的超時邏輯上取決於服務器連接, 所以改變這個值只影響服務器的新連接, 不影響任何已存在的連接.
http.ServerResponse 類#
該對象在 HTTP 服務器內部被創建。 它作為第二個參數被傳入 'request' 事件。
這個類實現了（而不是繼承自）可寫流 接口。 它是一個有以下事件的 EventEmitter：
'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.connection#
See response.socket.
response.end([data][, encoding][, callback])#
data<string> | <Buffer>encoding<string>callback<Function>
該方法會通知服務器，所有響應頭和響應主體都已被發送，即服務器將其視為已完成。 每次響應都必須調用 response.end() 方法。
如果指定了 data，則相當於調用 response.write(data, encoding) 之后再調用 response.end(callback)。
如果指定了 callback，則當響應流結束時被調用。
response.finished#
返回一個布爾值，表示響應是否已完成。 默認為 false。 執行 response.end() 之后，該值會變為 true。
response.getHeader(name)#
讀取一個已入隊列但尚未發送到客戶端的響應頭。 注意，名稱不區分大小寫。
例子：
const contentType = response.getHeader('content-type'); response.getHeaderNames()#
- Returns: <Array>
返回一個包含當前響應唯一名稱的 http 頭信息名稱數組. 名稱均為小寫.
示例:
response.setHeader('Foo', 'bar'); response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']); const headerNames = response.getHeaderNames(); // headerNames === ['foo', 'set-cookie'] response.getHeaders()#
- Returns: <Object>
返回當前響應頭文件的淺拷貝。 由於使用了淺拷貝，因此數組值可能會改變，無需對各種與響應頭相關的http模塊方法進行額外調用。 返回對象的鍵是響應頭名稱，值是各自的響應頭值。 所有響應頭名稱都是小寫的。
注意：response.getHeaders() 方法返回的對象不會原型繼承 JavaScript Object。 這意味着，沒有定義典型的Object方法，如obj.toString()，obj.hasOwnProperty() 和其他方法，並且不起作用。
例子：
response.setHeader('Foo', 'bar'); response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']); const headers = response.getHeaders(); // headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] } response.hasHeader(name)#
如果響應頭當前有設置 name 頭部，返回 true。請注意，名稱匹配不區分大小寫。
例子：
const hasContentType = response.hasHeader('content-type'); response.headersSent#
返回一個布爾值（只讀）。 如果響應頭已被發送則為 true，否則為 false。
response.removeHeader(name)#
name<string>
從隱式發送的隊列中移除一個響應頭。
例子：
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() 的優先。
// 返回 content-type = text/plain const 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'); }); response.setTimeout(msecs[, callback])#
msecs<number>callback<Function>
設置 socket 的超時時間為 msecs。 如果提供了回調函數，則它會作為監聽器被添加到響應對象的 'timeout' 事件。
如果沒有 'timeout' 監聽器被添加到請求、響應或服務器，則 socket 會在超時后被銷毀。 如果在請求、響應或服務器的 'timeout' 事件上分配了回調函數，則超時的 socket 必須被顯式地處理。
返回 response。
response.socket#
引用底層socket。 通常用戶不想訪問此屬性。 特別地，由於協議解析器連接到socket的方式，socket將不會發出'readable'事件。 在response.end()之后，該屬性為null。 也可以通過response.connection來訪問socket。
例如:
const http = require('http'); const server = http.createServer((req, res) => { const ip = req.socket.remoteAddress; const port = req.socket.remotePort; res.end(`你的IP地址是${ip}，你的源端口是${port}.`); }).listen(3000); response.statusCode#
當使用隱式的響應頭時（沒有顯式地調用 response.writeHead()），該屬性控制響應頭刷新時將被發送到客戶端的狀態碼。
例子：
response.statusCode = 404; 響應頭被發送到客戶端后，該屬性表示被發出的狀態碼。
response.statusMessage#
當使用隱式的響應頭時（沒有顯式地調用 response.writeHead()），該屬性控制響應頭刷新時將被發送到客戶端的狀態信息。 如果該值為 undefined，則使用狀態碼的標准信息。
例子：
response.statusMessage = 'Not found'; 響應頭被發送到客戶端后，該屬性表示被發出的狀態信息。
response.write(chunk[, encoding][, callback])#
chunk<string> | <Buffer>encoding<string>callback<Function>- 返回: <boolean>
如果該方法被調用且 response.writeHead() 沒有被調用，則它會切換到隱式響應頭模式並刷新隱式響應頭。
該方法會發送一塊響應主體。 它可被多次調用，以便提供連續的響應主體片段。
請注意在http模塊中，當請求是HEAD請求時，響應主體被省略。 類似地，204和304響應 不能 包括消息體。
chunk 可以是一個字符串或一個 buffer。 如果 chunk 是一個字符串，則第二個參數指定如何將它編碼成一個字節流。 encoding默認為 'utf8'。 當數據塊被刷新時，callback 會被調用。
注意：這是原始的 HTTP 主體，且與可能被使用的高級主體編碼無關。
response.write() 首次被調用時，會發送緩沖的響應頭信息和響應主體的第一塊數據到客戶端。 response.write() 第二次被調用時，Node.js 會以流的形式處理數據，並將它們分別發送。 也就是說，響應會被緩沖到響應主體的第一個數據塊。
如果全部數據被成功刷新到內核緩沖區，則返回 true。 如果全部或部分數據還在內存中排隊，則返回 false。 當緩沖區再次空閑時，則觸發 'drain' 事件。
response.writeContinue()#
發送一個 HTTP/1.1 100 Continue 消息到客戶端，表示請求主體可以開始發送。 參閱 Server 的 'checkContinue' 事件。
response.writeHead(statusCode[, statusMessage][, headers])#
發送一個響應頭給請求。 狀態碼是一個三位數的 HTTP 狀態碼，如 404。 最后一個參數 headers 是響應頭。 第二個參數 statusMessage 是可選的狀態描述。
例子：
const 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/plain const 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 是以字節（而不是字符）為單位的。 上面的例子行得通是因為字符串 'hello world' 只包含單字節字符。 如果響應主體包含高級編碼的字符，則應使用 Buffer.byteLength() 來確定在給定編碼中的字節數。 Node.js 不會檢查 Content-Length 與已發送的響應主體的長度是否相同。
如果響應頭字段的名稱或值包含無效字符，則拋出 TypeError 錯誤。
http.IncomingMessage 類#
IncomingMessage 對象由 http.Server 或 http.ClientRequest 創建，並作為第一個參數分別遞給 'request' 和 'response' 事件。 它可以用來訪問響應狀態、消息頭、以及數據。
它實現了 可讀流 接口，還有以下額外的事件、方法、以及屬性。
'aborted' 事件#
當請求已被客戶端終止且網絡 socket 已關閉時觸發。
'close' 事件#
當底層連接被關閉時觸發。 同 'end' 事件一樣，該事件每個響應只觸發一次。
message.destroy([error])#
error<Error>
調用接收到 IncomingMessage 的 socket 上的 destroy() 方法。 如果提供了 error，則觸發 'error' 事件，且把 error 作為參數傳入事件的監聽器。
message.headers#
請求頭或響應頭的對象。
頭信息的名稱與值的鍵值對。 頭信息的名稱為小寫。 例如：
// 輸出類似以下的東西： // // { 'user-agent': 'curl/7.22.0', // host: '127.0.0.1:8000', // accept: '*/*' } console.log(request.headers); 原始頭信息中的重復數據會按以下方式根據頭信息名稱進行處理：
- 重復的
age、authorization、content-length、content-type、etag、expires、from、host、if-modified-since、if-unmodified-since、last-modified、location、max-forwards、proxy-authorization、referer、retry-after、或user-agent會被丟棄。 set-cookie始終是一個數組。重復的會被添加到數組。- 對於其他頭信息，其值使用
,拼接。
message.httpVersion#
在服務器請求中，該屬性返回客戶端發送的 HTTP 版本。 在客戶端響應中，該屬性返回連接到的服務器的 HTTP 版本。 可能的值有 '1.1' 或 '1.0'。
message.httpVersionMajor 返回 HTTP 版本的第一個整數值，message.httpVersionMinor 返回 HTTP 版本的第二個整數值。
message.method#
僅在 http.Server 返回的請求中有效。
返回一個字符串，表示請求的方法。 該屬性只讀。 例如：'GET'、'DELETE'。
message.rawHeaders#
接收到的原始的請求頭或響應頭列表。
注意，鍵和值在同一個列表中。 偶數位的是鍵，奇數位的是對應的值。
頭信息的名稱不會被轉換為小寫，重復的也不會被合並。
// 輸出類似以下的東西： // // [ '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#
接收到的原始的 Trailer 請求頭或響應頭的的鍵和值。 只在 'end' 事件時被賦值。
message.setTimeout(msecs, callback)#
msecs<number>callback<Function>
調用 message.connection.setTimeout(msecs, callback)。
返回 message。
message.socket#
返回與連接關聯的 net.Socket 對象。
通過 HTTPS 的支持，使用 request.socket.getPeerCertificate() 獲取客戶端的認證信息。
message.statusCode#
僅在 http.ClientRequest 返回的響應中有效。
返回一個三位數的 HTTP 響應狀態碼。 如 404。
message.statusMessage#
僅在 http.ClientRequest 返回的響應中有效。
返回 HTTP 響應狀態消息（原因描述）。 如 OK 或 Internal Server Error。
message.trailers#
返回 Trailer 請求頭或響應頭對象。 只在 'end' 事件時被賦值。
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') Url { protocol: null, slashes: null, auth: null, host: null, port: null, hostname: null, hash: null, search: '?name=ryan', query: 'name=ryan', pathname: '/status', path: '/status?name=ryan', href: '/status?name=ryan' } 如果想從查詢字符串中提取參數，可以使用 require('querystring').parse 函數、或為 require('url').parse 的第二個參數傳入 true。 例子：
$ node
> require('url').parse('/status?name=ryan', true) Url { protocol: null, slashes: null, auth: null, host: null, port: null, hostname: null, hash: null, search: '?name=ryan', query: { name: 'ryan' }, pathname: '/status', path: '/status?name=ryan', href: '/status?name=ryan' } http.METHODS#
返回解析器支持的 HTTP 方法的列表。
http.STATUS_CODES#
返回標准的 HTTP 響應狀態碼的集合，以及各自的簡短描述。 例如，http.STATUS_CODES[404] === 'Not Found'。
http.createServer([requestListener])#
-
requestListener<Function> -
返回: <http.Server>
返回一個新建的 http.Server 實例。
requestListener 是一個函數，會被自動添加到 'request' 事件。
http.get(options[, callback])#
options<Object> | <string> | <URL> Accepts the sameoptionsashttp.request(), with themethodalways set toGET. Properties that are inherited from the prototype are ignored.callback<Function>- 返回: <http.ClientRequest>
因為大多數請求都是 GET 請求且不帶請求主體，所以 Node.js 提供了該便捷方法。 該方法與 http.request() 唯一的區別是它設置請求方法為 GET 且自動調用 req.end()。 注意，響應數據必須在回調中被消耗，原因詳見 http.ClientRequest 章節。
callback 被調用時只傳入一個參數，該參數是 http.IncomingMessage 的一個實例。
一個獲取 JSON 的例子：
http.get('http://nodejs.org/dist/index.json', (res) => { const { statusCode } = res; const contentType = res.headers['content-type']; let error; if (statusCode !== 200) { error = new Error('請求失敗。\n' + `狀態碼: ${statusCode}`); } else if (!/^application\/json/.test(contentType)) { error = new Error('無效的 content-type.\n' + `期望 application/json 但獲取的是 ${contentType}`); } if (error) { console.error(error.message); // 消耗響應數據以釋放內存 res.resume(); return; } res.setEncoding('utf8'); let rawData = ''; res.on('data', (chunk) => { rawData += chunk; }); res.on('end', () => { try { const parsedData = JSON.parse(rawData); console.log(parsedData); } catch (e) { console.error(e.message); } }); }).on('error', (e) => { console.error(`錯誤: ${e.message}`); }); http.globalAgent#
Agent 的全局實例，作為所有 HTTP 客戶端請求的默認 Agent。
http.request(options[, callback])#
options<Object> | <string> | <URL>protocol<string> 使用的協議。默認為http:。host<string> 請求發送至的服務器的域名或 IP 地址。默認為localhost。hostname<string>host的別名。為了支持url.parse()，hostname優於host。family<number> 當解析host和hostname時使用的 IP 地址族。 有效值是4或6。當未指定時，則同時使用 IP v4 和 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<Function> 當不使用agent選項時，為請求創建一個 socket 或流。 這可以用於避免僅僅創建一個自定義的Agent類來覆蓋默認的createConnection函數。詳見agent.createConnection()。timeout<number>: 指定 socket 超時的毫秒數。 它設置了 socket 等待連接的超時時間。
callback<Function>- 返回: <http.ClientRequest>
Node.js 為每台服務器維護多個連接來進行 HTTP 請求。 該函數允許顯式地發出請求。
options 可以是一個對象、或字符串、或 URL 對象。 如果 options 是一個字符串，它會被自動使用 url.parse() 解析。 If it is a URL object, it will be automatically converted to an ordinary options object.
可選的 callback 參數會作為單次監聽器被添加到 'response' 事件。
http.request() 返回一個 http.ClientRequest 類的實例。 ClientRequest 實例是一個可寫流。 如果需要通過 POST 請求上傳一個文件，則寫入到 ClientRequest 對象。
例子：
const postData = querystring.stringify({ 'msg' : 'Hello World!' }); const options = { hostname: 'www.google.com', port: 80, path: '/upload', method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(postData) } }; const req = http.request(options, (res) => { console.log(`狀態碼: ${res.statusCode}`); console.log(`響應頭: ${JSON.stringify(res.headers)}`); res.setEncoding('utf8'); res.on('data', (chunk) => { console.log(`響應主體: ${chunk}`); }); res.on('end', () => { console.log('響應中已無數據。'); }); }); req.on('error', (e) => { console.error(`請求遇到問題: ${e.message}`); }); // 寫入數據到請求主體 req.write(postData); req.end(); 注意，在例子中調用了 req.end()。 使用 http.request() 必須總是調用 req.end() 來表明請求的結束，即使沒有數據被寫入請求主體。
如果請求過程中遇到任何錯誤（DNS 解析錯誤、TCP 級的錯誤、或實際的 HTTP 解析錯誤），則在返回的請求對象中會觸發 'error' 事件。 對於所有的 'error' 事件，如果沒有注冊監聽器，則拋出錯誤。
以下是需要注意的幾個特殊的請求頭。
-
發送
'Connection: keep-alive'會通知 Node.js，服務器的連接應一直持續到下一個請求。 -
發送
'Content-Length'請求頭會禁用默認的塊編碼。 -
發送
'Expect'請求頭會立即發送請求頭。 通常情況下，當發送'Expect: 100-continue'時，超時時間與continue事件的監聽器都需要被設置。 詳見 RFC2616 章節 8.2.3。 -
發送
Authorization請求頭會替代auth選項計算基本身份驗證。
Example using a URL as options:
const { URL } = require('url'); const options = new URL('http://abc:xyz@example.com'); const req = http.request(options, (res) => { // ... });