nodeJS之HTTP

HTTP不是基于特定語言的，是一個通用的應用層協議，不同語言有不同的實現細節，但是萬變不離其宗，思想是相同的。NodeJS作為一個宿主運行環境，以JavaScript為宿主語言，它也有自己實現的一套標準，本文將詳細介紹nodeJS中的Http模塊

Agent

【new 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

　　http.request() 使用的默認 http.globalAgent 的選項均為各自的默認值

　　若要配置其中任何一個，則需要創建自定義的 http.Agent 實例

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

options <Object> 包含連接詳情的選項
callback <Function> 接收被創建的 socket 的回調函數。callback 有 (err, stream) 參數
返回: <net.Socket>

　　創建一個用于 HTTP 請求的 socket 或流

　　默認情況下，函數類似于net.createConnection()。但如果期望更大的靈活性，自定義代理可重寫該方法

　　socket 或流可以通過以下兩種方式獲取：從該函數返回或傳入callback

【agent.destroy()】

　　銷毀當前正被代理使用的任何socket

　　通常不需要這么做。但是如果使用的代理啟用了keepAlive，則當確定它不再被使用時，最好顯式地關閉代理。 否則，在服務器終止它們之前，socket 可能還會長時間保持打開

【agent.freeSockets】

　　返回一個對象，包含當前正在等待被啟用了 keepAlive 的代理使用的 socket 數組。不要修改該屬性

【agent.getName(options)】

options <Object> 為名稱生成程序提供信息的選項。
    host <string> 請求發送至的服務器的域名或 IP 地址。
    port <number> 遠程服務器的端口。
    localAddress <string> 當發送請求時，為網絡連接綁定的本地接口。
返回: <string>

　　為請求選項的集合獲取一個唯一的名稱，用來判斷一個連接是否可以被復用。 對于 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 數組。 不要修改

Request

【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 與已傳輸的請求主體的長度是否相等

var http = require('http');var server = http.createServer(function(req, res){
    console.log(req.url );//'/'
    console.log(req.httpVersion );//1.1
    console.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":"p_w_picpath/webp,p_w_picpath/*,*/*;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事件】

　　當請求已被客戶端終止時觸發。 該事件僅在首次調用 abort() 時觸發

【aborted事件】

　　當請求已被服務器終止且網絡 socket 已關閉時觸發

【connect事件】

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

　　當服務器響應CONNECT請求時觸發。 如果該事件未被監聽，則接收到CONNECT方法的客戶端會關閉連接

【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 請求頭的客戶端會關閉連接

【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 <Error>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.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 訪問

【upgrade事件】

request <http.IncomingMessage> HTTP 請求，同 'request' 事件。
socket <net.Socket> 服務器與客戶端之間的網絡 socket。
head <Buffer> 流的第一個數據包，可能為空。

　　每當客戶端發送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> | <Buffer>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>返回: <http.ClientRequest>

　　因為大多數請求都是 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 <Function> 當不使用 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 <Function>

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