Express4.x api 翻譯（draft）

時間 2019-12-20

標籤 express4.x express api 翻譯 draft 简体版

原文原文鏈接

用了一年多的 Express了，其實會用的功能也能基本知足業務的需求，可是老是感受本身對其的掌握仍是缺乏一種系統性。故翻譯其api，以期本身在翻譯過程當中對其有更深的認識。

翻譯的內容還比較粗糙，歡迎在此處提建議進行修改。

`express()`

用以生成一個Express應用，express()函數是從express模塊導出的頂級函數。css

var express = require('express');
var app = express();

方法

`express.json([options])`

此方法支持Express4.16.0及更新的版本，用於取代 body-parser

這是Express提供的一個內置中間件函數，它基於body-parser用以解析傳入的請求爲JSON格式。html

本函數返回只解析JSON的中間件,而且只做用於Content-Type請求頭與type選項匹配的請求。此解析器可接收任何編碼格式的body,支持自動解壓gzip和壓縮deflate編碼。java

在進過此中間件處理後，request對象中會添加body屬性（如req.body），它是一個對象，其中包含解析而來的數據,若是請求中沒有body可供解析或Content-Type不匹配抑或發生了錯誤，body則會是一個空對象({})。node

下表描述了可選的options對象的屬性：jquery

屬性	描述	類型	默認值
`inflate`	是否容許處理壓縮的請求體，當設置爲`false`時，壓縮請求體的請求會被拒絕	Boolean	`true`
`limit`	控制請求體的大小，若是是一個數值，爲指定的字節數，若是是一個字符串，該值會被傳給bytes庫進行解析	Mixed	"100kb"
`reviver`	`reviver`選項會直接傳遞給`JSON.parse`作爲第二個參數，能夠在mdn上查看更多信息	Function	null
`strict`	是否只接收數組或對象，當設置爲false時能接收任何`JSON.parse`可處理的類型	Boolean	`true`
`type`	用於肯定中間件將處理那種媒體類型，其值能夠是一個字符串，字符串構成的數組或者一個函數，當不是一個函數時，該值會被傳輸給`type-is`庫進行處理，該值還能夠是一個拓展名（如`json`）,`mime type`(如`application/json`)或者包含通配符的 `mime type` （如`/` 或者 `*/json`），若是是一個函數，`type`類型將經過`fn(req)`調用，若是返回的是一個有效值，請求會被解析	Mixed	"application/json"
`verify`	若是這個選項被支持，將以`verify(req, res, buf, encoding)`形式被調用，其中`buf`是由原始請求體構成的`Buffer`,`encoding`是請求的編碼，解析能夠經過拋出錯誤而放棄	Function	`undefined`

`express.static(root,[options])`

這也是Express內置中間件之一，它基於serve-static構建，用於提供靜態文件。git

Note: 使用反向代理緩存能夠提升靜態文件服務器的效率

root參數指定提供靜態文件的根目錄。服務器將拼合req.url和所提供的根目錄來查找靜態文件。若是沒有找到對應的文件，服務器不會返回404，而將調用next()以執行下一個中間件，容許堆疊和回退。github

何謂倒退

下表描述了可選的options對象中可配置的屬性：web

屬性	描述	類型	默認值
`dotfiles`	決定如何看待以點開頭的文件	String	"ignore"
`etag`	是否生成`etag`,`express.static`始終生成弱校驗Etags	Boolean	true
`extensions`	設置文件的備選拓展名，若是一個文件沒有找到則依據此處的設置尋找是否有其它後綴的文件並將發送第一個找到的文件，如`['html','htm']`	Mixed	false
`fallthrough`	讓客戶端的錯誤做爲未處理的請求，不然轉發客戶端錯誤,詳見下文	Boolean	true
`immutable`	在`Cache-Control`響應頭中啓用或禁用不可變的指令。若是啓用，還應指定maxAge選項以啓用緩存。不可變的指令將阻止受支持的客戶端在maxAge有效期間發出檢查文件是否已更改的條件請求。	Boolean	false
`index`	發送指定的目錄索引文件。設置爲false以禁用目錄索引	Mixed	"index.html"
`lastModified`	將`Last-Modified`頭部信息設置爲文件在該系統上的最後修改日期	Boolean	true
`maxAge`	以毫秒爲單位設置`Cache-Control`頭部信息的`max-age`屬性，或以ms格式設置字符串	Number	0
`redirect`	當路徑名是一個目錄時，自動在後面加上「/」	Boolean	true
`setHeaders`	用於設置HTTP頭文件的函數	Function

更多信息可查看Serving static files in Express和Using middleware - Built-in middleware.正則表達式

ETag是HTTP協議提供的若干機制中的一種Web緩存驗證機制，而且容許客戶端進行緩存協商。這就使得緩存變得更加高效，並且節省帶寬。若是資源的內容沒有發生改變，Web服務器就不須要發送一個完整的響應。ETag也可用於樂觀併發控制[1]，做爲一種防止資源同步更新而相互覆蓋的方法。
強校驗的ETag匹配要求兩個資源內容的每一個字節需徹底相同，包括全部其餘實體字段（如Content-Language）不發生變化。強ETag容許從新裝配和緩存部分響應，以及字節範圍請求。弱校驗的ETag匹配要求兩個資源在語義上相等，這意味着在實際狀況下它們能夠互換，並且緩存副本也可使用。不過這些資源不須要每一個字節相同，所以弱ETag不適合字節範圍請求。當Web服務器沒法生成強ETag不切實際的時候，好比動態生成的內容，弱ETag就可能發揮做用了。

dotfiles

此選項的可選值有如下幾個：

allow:不會特別對待以點開頭的文件；
deny:拒絕返回以點開頭的文件，會返回403錯誤並調用next()
ignore:忽略對以點開頭的文件的請求，返回404錯誤並調用next()

Note: 使用默認值，不會忽略文件夾中的以點開頭的文件

fallthrough

當此選項設置爲true,諸如無效請求或請求不存在的文件時將引發中間件調用next(),使得下一個中間件位於棧中。設置爲false時，這些錯誤將觸發next(err)。

將此選項設置爲true，可讓你映射多個物理目錄到相同的Web地址或者調用路由來充填不存在的文件。

若是你想讓某路徑嚴格限制在某文件系統中則可使用false,經過404短路能夠減少服務器壓力，
若是您將此中間件安裝在嚴格意義上爲單個文件系統目錄的路徑上，則可使用false，這樣可使404短路，從而減小開銷，這個中間件對全部的請求方法生效。

setHeaders

此選項用於指定一個函數用以自定義相應頭，必須使用同步方法修改頭部內容。函數簽名以下：

fn(res, path, stat)

各選項意義以下：

res,響應對象
path,發送的文件的路徑
stat,發送的文件的stat對象

`express.static`使用示例

var options = {
  dotfiles: 'ignore',
  etag: false,
  extensions: ['htm', 'html'],
  index: false,
  maxAge: '1d',
  redirect: false,
  setHeaders: function (res, path, stat) {
    res.set('x-timestamp', Date.now())
  }
}

app.use(express.static('public', options))

`express.Router([options])`

建立一個新的router對象

var router = express.Router([options]);

可選參數option對象中的屬性以下

屬性	描述	默認值	兼容性
`caseSensitive`	是否啓用大小寫敏感	默認不啓用，這意味着`/Foo`和`foo`是同樣的
`mergeParams`	是否保存父路由中的`req.params`值，若是相互衝突，取子路由中的值	`false`	4.5.0+
`strict`	是否啓用嚴格匹配	默認禁止，`/foo`和`/foo/`的響應一致

你能夠像對待express應用同樣，給router添加中間件和各類方法。

`express.urlencoded([options])`

此中間件適用於Express v4.16.0及更新的方法

這是Express提供的一個內置中間件，它基於body-parser解析傳入的請求爲urlencoded格式。

返回只解析urlencoded的中間件,並且只解析請求頭的Content-Type與type匹配的請求。此解析器只接收 UTF-8編碼格式的body,支持自動解壓gzip和壓縮編碼。

進過此中間件處理後，會返回response對象中將包含body對象（如req.body）其中包含解析所得數據,若是沒有body可供解析或Content-Type不匹配或發生錯誤則會返回一個空對象({})。對象的值能夠是字符串或者數組（當extended爲false時），或者其它任意類型（當extended爲true時）。

下表描述了可選的options對象中可配置的屬性：

屬性	描述	類型	默認值
`extended`	此選項將決定會使用`querystring`庫（`false`時）仍是`qs`庫（`true`時）來解析`URL-encoded`數據。「extended」語法容許將對象和數組編碼爲URL格式，從而達到使用URL編碼的相似得到相似JSON的體驗。查看qs瞭解更多信息	Boolean	true
`inflate`	是否容許處理壓縮的請求體，當設置爲false時，壓縮請求體的請求會被拒絕	Boolean	true
`limit`	控制請求體的大小，若是是一個數值，爲指定的字節數，若是是一個字符串，該值會被傳給bytes庫進行解析	Mixed	"100kb"
`parameterLimit`	該選項控制URL編碼數據中容許的最大參數數量。若是一個請求包含比這個值更多的參數，將會引起一個錯誤。	Bumber	1000
`type`	用於肯定中間件將處理那種媒體類型，其值能夠是一個字符串，字符串構成的數組或者一個函數，若是不是一個函數，該值會被直接傳輸給`type-is`庫，值能夠是一個拓展名（如`urlencoded`）,`mime type`(如 `"application/x-www-form-urlencoded"`)或者包含通配符的 `mime type` （如`/` 或者 `*/json`），若是是一個函數，`type`類型將經過`fn(req)`調用而且若是返回一個真值請求會被解析	Mixed	"application/x-www-form-urlencoded"
`verify`	若是這個選項被支持，將以`verify(req, res, buf, encoding)`形式被調用，其中`buf`是由原始請求體構成的`Buffer`,`encoding`是請求的編碼，解析能夠經過拋出錯誤而放棄	Function	`undefined`

Application

app對象常被用來表示Express應用，它經過調用Express模塊提供的頂級函數express()生成

var express = require('express');
var app = express();

app.get('/', function(req, res){
  res.send('hello world');
});

app.listen(3000);

app對象具有如下方法：

依據http請求路徑註冊處理函數，可查看app.METHOD和app.param;
配置中間件，見app.route;
渲染html視圖，見app.render
設置模板渲染引擎，見app.engine

app對象還提供一些其它的影響應用行爲的配置，能夠查看Application settings瞭解更多信息。

Express appliaction 對象能夠分別以 req.app 和 res.app 指向 request對象 和 response對象。

屬性

`app.locals`

app.locals是一個對象，其以app內部的各變量爲屬性

app.locals.title
// => 'My App'

app.locals.email
// => 'me@myapp.com'

一旦設置，app.locals屬性將在整個應用的生命週期內有效，相比而言res.locals的屬性值則只在某請求的生命週期內有效。

你能夠在app渲染的模板的過程當中訪問本地變量。這樣就能夠爲模板提供輔助函數及app級別的數據，app本地變量在中間件中能夠經過req.app.locals訪問（詳見req.app）

app.locals.title = 'My App';
app.locals.strftime = require('strftime');
app.locals.email = 'me@myapp.com';

`app.mountpath`

app.mountpath屬性用以表示某sub-app所匹配的一個或多個路徑模式。

sub-app指的是用於處理對路由的請求的 express的實例。

var express = require('express');

var app = express(); // the main app
var admin = express(); // the sub app

admin.get('/', function (req, res) {
  console.log(admin.mountpath); // /admin
  res.send('Admin Homepage');
});

app.use('/admin', admin); // mount the sub app

它和req對象提供的baseUrl功能相似，不一樣之處在於req.baseUrl返回的是匹配的URL路徑而非匹配模式。

若是一個sub-app有多種路徑匹配模式，sub-app.mountpath將返回一個模式的列表

var admin = express();

admin.get('/', function (req, res) {
  console.log(admin.mountpath); // [ '/adm*n', '/manager' ]
  res.send('Admin Homepage');
});

var secret = express();
secret.get('/', function (req, res) {
  console.log(secret.mountpath); // /secr*t
  res.send('Admin Secret');
});

admin.use('/secr*t', secret); // load the 'secret' router on '/secr*t', on the 'admin' sub app
app.use(['/adm*n', '/manager'], admin); // load the 'admin' router on '/adm*n' and '/manager', on the parent app

次級app還能夠再擁有次級app，若是如此，那次級 app和 router的區別在哪兒呢？
router其實只具有部分功能， sub-app具有所有功能

Events

`app.on('mount',callback(parent))`

mount事件在sub-app掛載（mount）到父app時觸發，父app會當作參數傳入回調函數中。

Note:
Sub-app將：

- 不繼承`settings`中的默認值，在sub-app中須要從新設置；
- 將繼承沒有默認值的`settings`中的值

var admin = express();

admin.on('mount', function (parent) {
  console.log('Admin Mounted');
  console.log(parent); // refers to the parent app
});

admin.get('/', function (req, res) {
  res.send('Admin Homepage');
});

app.use('/admin', admin);

Methods

`app.all(path,callback[,callback])`

此方法相似標準的app.MEYHOD()方法，不一樣的地方在於它將匹配全部類型的http請求。

參數

參數1： path 默認值： /(root path)

描述：

中間件被觸發的路徑，能夠是如下值中的一種：
- 用字符串表達的路徑
- 匹配路徑的正則表達式
- 路徑模式
- 上述值組成的數組
能夠點擊Path examples查看實際的例子

參數2： callback 默認值： None

描述：

回調函數能夠是以下中的一種：
- 一箇中間件函數
- 由逗號隔開的一系列中間件函數
- 一個由中間件函數構成的數組
- 上述狀況的組合
您能夠提供多個回調函數，其行爲與中間件相似，只不過這些回調能夠調用next（'route'）來繞過剩餘的路由回調。你可使用此機制來決定應該使用哪一個路由，若是沒有繼續使用當前路由的理由，則能夠調到下一個路由。

因爲router和app都實現了中間件接口，所以你也能夠把它們當作中間件使用。

可在此處參考示例

示例

如下回調將響應GET，POST，PUT，DELETE或任何其餘HTTP請求方法對路由/secret的請求：

app.all('/secret', function (req, res, next) {
  console.log('Accessing the secret section ...')
  next() // pass control to the next handler
});

app.all()方法在處理對某特定的前綴或匹配的特殊路徑的全部類型的請求時特別有用。好比說若是你把下述代碼放在全部其它路徑的定義以前，就會讓今後代碼以後的全部路由都須要身份驗證，並自動加載一個user。這些回調也沒必要作爲終點，loadUser能夠用來執行某個任務，而後調用next()來繼續匹配以後的路由。

app.all('*', requireAuthentication, loadUser);

上述代碼也等同於

app.all('*', requireAuthentication);
app.all('*', loadUser);

下面還有另一個很是有用的app.all使用示例，此例和上面的例子相似，可是嚴格限制路徑以/api開頭

app.all('/api/*', requireAuthentication);

`app.delete(path, callback [, callback ...])`

爲某路徑的HTTP DELETE請求綁定特定的回調函數。更多信息可查看路由指南。

參數

參數1： path 默認值： /(root path)

描述：

路徑模式能夠是如下類型中的一種：
- 路徑字符串
- 匹配路徑的正則表達式
- 通配符
- 上述類型值組成的數組
點擊Path examples可查看更多實際的例子

參數2： callback 默認值： None

描述：

回調函數能夠是以下類型中的一種：
- 一箇中間件函數
- 由逗號隔開的一系列中間件函數
- 一個由中間件函數構成的數組
- 上述狀況的組合
能夠提供多個回調函數，多個回調函數的調用與多箇中間件的調用相似，不一樣之處在於在回調函數中調用next（'route'）可繞過以後的回調函數。你能夠基於此機制來以爲是否須要觸發以後的回調函數

router和app都實現了中間件接口，你能夠像使用中間件同樣使用它們。

可在此處參考示例

示例

app.delete('/', function (req, res) {
  res.send('DELETE request to homepage');
});

`app.disable(name)`

設置setting中的布爾值屬性name的值爲false，name是app settings表中的值爲布爾型的項。調用app.set('foo',false)和調用app.disable('foo')的效果一致：

如：

app.disable('trust proxy');
app.get('trust proxy');
// => false

`app.disabled(name)`

判斷setting中的設置項name的值是否爲false,若是setting中的設置項name的值爲false則返回true,name是app settings表中的值爲布爾型的項。

app.disabled('trust proxy');
// => true

app.enable('trust proxy');
app.disabled('trust proxy');
// => false

`app.enable(name)`

設置setting中的布爾值設置項name爲true,調用app.enable('foo')和調用app.set('foo',true)效果相同。

app.enable('trust proxy');
app.get('trust proxy');
// => true

`app.enabled(name)`

判斷setting中的設置項name的值是否爲true,若是setting中的設置項name的值爲true則返回true,name是app settings表中的值爲布爾型的項。

app.enabled('trust proxy');
// => false

app.enable('trust proxy');
app.enabled('trust proxy');
// => true

`app.engine(ext,callback)`

註冊ext格式的模板的回調函數爲callback。

默認狀況下，Express會基於拓展名require()引擎，好比說，若是你渲染文件foo.pug,Express將在內部觸發如下代碼，並會爲接下來的請求緩存require()以提升性能。

app.engine('pug', require('pug').__express);

對不提供直接可用的.__express的引擎，或者你想把不一樣的後綴映射到當前引擎可使用下述方法，

// 使用EJS引擎來渲染`.html`文件
app.engine('html', require('ejs').renderFile);

在上面的例子中，renderFile()方法提供了Express想要的相同的簽名（path,options,callback）,不過請注意這個方法會自動在內部調用ejx.__express)因此若是你想要渲染的文件的後綴是.ejx,則不須要調用作別的事情。

也有一些模板引擎不遵循這個約定，consolidate.js庫能夠映射 Node 模板引擎爲準守這種規律，因此他們能夠和Express無縫連接使用。

var engines = require('consolidate');
app.engine('haml', engines.haml);
app.engine('html', engines.hogan);

`app.get(name)`

返回app setting 中相關屬性name的值，如：

app.get('title');
// => undefined

app.set('title', 'My Site');
app.get('title');
// => "My Site"

`app.get(path,callback[,callback])`

使用特定的回調函數處理特定路徑的HTTP GET請求

參數

參數1： path 默認值： /(root path)

描述：

中間件被觸發的路徑，能夠是如下值中的一種：
- 路徑字符串
- 匹配路徑的正則表達式
- 路徑模式
- 上述值組成的數組
能夠點擊Path examples查看實際的例子

參數2： callback 默認值： None

描述：

回調函數能夠是以下中的一種：
- 中間件函數
- 由逗號隔開的一系列中間件函數
- 一個由中間件函數構成的數組
- 上述狀況的組合
能夠提供多個回調函數，多個回調函數的調用與多箇中間件的調用相似，不一樣之處在於在回調函數中調用next（'route'）可繞過以後的回調函數。你能夠基於此機制來以爲是否須要觸發以後的回調函數

router和app都實現了中間件接口，你能夠像使用其餘中間件功能同樣使用它們。

可在此處參考示例

更多信息可參考routing 指南

`app.listen(path,[callback])`

啓動UNIX套接字並偵聽指定路徑上的鏈接。此方法等同於Node的http.Server.listen()方法.

var express = require('express');
var app = express();
app.listen('/tmp/sock');

`app.listen(port,[hostname],[backlog],[callback])`

綁定並監聽對指定的host和端口的鏈接。此方法和Node的http.Server.listen()方法一致。

var express = require('express');
var app = express();
app.listen(3000);

由express()方法返回的app其實是一個JavaScript Function,它實際上被設計爲傳遞給Node的HTTP servers做爲回調函數來處理請求。因爲 app 並無什麼繼承，這使得能夠很是方便使用同一套代碼提供http或https版本的app。

var express = require('express');
var https = require('https');
var http = require('http');
var app = express();

http.createServer(app).listen(80);
https.createServer(options, app).listen(443);

app.listen()方法返回一個http.Server對象，對於http來講，它能夠像下面這樣使用

app.listen = function() {
  var server = http.createServer(this);
  return server.listen.apply(server, arguments);
};

`app.METHOD(path,callback[,callback])`

依據請求的類型處理http請求，請求類型能夠是GET,PUT,POST等等的小寫模式。所以，實際的方法是app.get(),app.post(),app.put()等等。點擊這裏能夠查看詳細的路由方法清單。

參數

參數1： path 默認值： /(root path)

描述：

路徑模式能夠是如下類型中的一種：
- 路徑字符串
- 匹配路徑的正則表達式
- 通配符
- 上述類型值組成的數組
點擊Path examples可查看更多實際的例子

參數2： callback 默認值： None

描述：

回調函數能夠是以下類型中的一種：
- 一箇中間件函數
- 由逗號隔開的一系列中間件函數
- 一個由中間件函數構成的數組
- 上述狀況的組合
能夠提供多個回調函數，多個回調函數的調用與多箇中間件的調用相似，不一樣之處在於在回調函數中調用next（'route'）可繞過以後的回調函數。你能夠基於此機制來以爲是否須要觸發以後的回調函數

router和app都實現了中間件接口，你能夠像使用中間件同樣使用它們。

可在此處參考示例

路由方法

Express下述路由方法，它們和對應的HTTP方法具備相同的名稱

checkout
copy
delete
get
head
lock
merge
mkactivity
mkcol
move
m-search
notify
options
patch
post
purge
put
report
search
subscribe
trace
unlock
unsubscribe

本API文檔中只對經常使用的HTTP方法進行了描述，如app.get(),app.post(),app.put()以及app.delete()。不過上面列出的其它方法使用方法也是相似的

對於無效的JavaScript變量名類型，可使用中括號來調用，好比app['m-search']('/', function ....

若是沒有在 app.get()前指定 HTTP HEAD對應的方法，將會調用 app.get()來響應 HEAD請求。

app.all會響應針對某個特定路徑的全部請求，詳細可參看。

更多信息可參考routing 指南

`app.param([name],callback)`

爲路由的參數添加回調函數，其中name是參數名或由參數組成的數組，callback是回調函數。回調函數的參數依次是請求對象(request)，響應對象(response),下一個中間件，參數值及參數名。

若是name是一個數組，回調函數會按照它們聲明的順序，依次註冊到回調函數，此時除了此數據中的最後一項，回調函數中的next將會觸發下一個註冊參數的回調函數，而對於最後一個參數，next則會調用處理當前路由的下一個中間件，此時的處理邏輯和name只是一個字符串同樣。

下面的例子實現了當:user存在於路由的路徑中時，在req對象中添加了req.user以供後期路由使用：

app.param('user', function(req, res, next, id) {

  // try to get the user details from the User model and attach it to the request object
  User.find(id, function(err, user) {
    if (err) {
      next(err);
    } else if (user) {
      req.user = user;
      next();
    } else {
      next(new Error('failed to load user'));
    }
  });
});

處理Param的回調函數對於包含它們的路由來講是本地的。所以不會被app或者其它的路由繼承。

Param回調函數會在在任何匹配了該路由的處理函數前觸發，而且一個請求響應週期內只會被觸發一次，即便參數匹配了多個路由也是如此。

app.param('id', function (req, res, next, id) {
  console.log('CALLED ONLY ONCE');
  next();
});

app.get('/user/:id', function (req, res, next) {
  console.log('although this matches');
  next();
});

app.get('/user/:id', function (req, res) {
  console.log('and this matches too');
  res.end();
});

對於請求GET /user/42將打印如下語句：

CALLED ONLY ONCE
although this matches
and this matches too

app.param(['id', 'page'], function (req, res, next, value) {
  console.log('CALLED ONLY ONCE with', value);
  next();
});

app.get('/user/:id/:page', function (req, res, next) {
  console.log('although this matches');
  next();
});

app.get('/user/:id/:page', function (req, res) {
  console.log('and this matches too');
  res.end();
});

對於請求 GET /user/42/3,下面語句將被打印

CALLED ONLY ONCE with 42
CALLED ONLY ONCE with 3
although this matches
and this matches too

源文檔中此處有一段已經自Express4.10棄用，此處再也不作翻譯

`app.path`

返回應用程序的規範路徑其是一個字符串。

var app = express()
  , blog = express()
  , blogAdmin = express();

app.use('/blog', blog);
blog.use('/admin', blogAdmin);

console.log(app.path()); // ''
console.log(blog.path()); // '/blog'
console.log(blogAdmin.path()); // '/blog/admin'

對於那些特別複雜加載了特別多app的程序，app.path的行爲會變得很複雜，這種狀況下使用req.baseUrl來獲取路徑更好。

`app.post(path,callback[,callback])`

綁定針對某特定路徑的HTTP POST請求到特定的回調函數上。更多信息可查看路由指南。

參數

參數1： path 默認值： /(root path)

描述：

路徑模式能夠是如下類型中的一種：
- 路徑字符串
- 匹配路徑的正則表達式
- 通配符
- 上述類型值組成的數組
點擊Path examples可查看更多實際的例子

參數2： callback 默認值： None

描述：

回調函數能夠是以下類型中的一種：
- 一箇中間件函數
- 由逗號隔開的一系列中間件函數
- 一個由中間件函數構成的數組
- 上述狀況的組合
能夠提供多個回調函數，多個回調函數的調用與多箇中間件的調用相似，不一樣之處在於在回調函數中調用next（'route'）可繞過以後的回調函數。你能夠基於此機制來以爲是否須要觸發以後的回調函數

router和app都實現了中間件接口，你能夠像使用中間件同樣使用它們。

可在此處參考示例

示例

app.post('/', function (req, res) {
  res.send('POST request to homepage');
});

`app.put(path,callback[,callback])`

綁定針對某特定路徑的HTTP POST請求到特定的回調函數上。更多信息可查看路由指南。

參數

參數1： path 默認值： /(root path)

描述：

路徑模式能夠是如下類型中的一種：
- 路徑字符串
- 匹配路徑的正則表達式
- 通配符
- 上述類型值組成的數組
點擊Path examples可查看更多實際的例子

參數2： callback 默認值： None

描述：

回調函數能夠是以下類型中的一種：
- 一箇中間件函數
- 由逗號隔開的一系列中間件函數
- 一個由中間件函數構成的數組
- 上述狀況的組合
能夠提供多個回調函數，多個回調函數的調用與多箇中間件的調用相似，不一樣之處在於在回調函數中調用next（'route'）可繞過以後的回調函數。你能夠基於此機制來以爲是否須要觸發以後的回調函數

router和app都實現了中間件接口，你能夠像使用中間件同樣使用它們。

可在此處參考示例

示例

app.put('/', function (req, res) {
  res.send('PUT request to homepage');
});

`app.render(view,[locals],callback)`

經過回調函數返回某個視圖對應渲染出的HTML，它接收一個可選的參數，這個參數是一個對象用以像視圖傳送本地變量。app.render()很像res.render()區別在於它自己不能發送渲染後的視圖給客戶端。

能夠把 app.render()看作用於生成視圖字符串的實用函數。事實上， res.render()在內部會使用 app.render()來渲染視圖。
本地變量cache被用來設置啓用視圖緩存，若是你想要在開發過程當中啓用，你須要將其設置爲true，視圖緩存在生產環境中默認被啓用。

app.render('email', function(err, html){
  // ...
});

app.render('email', { name: 'Tobi' }, function(err, html){
  // ...
});

`app.route(path)`

返回單一路由的實例，能夠鏈式的爲不一樣的請求綁定不一樣的中間件處理函數。使用app.route()能夠避免重複的寫路由名及由此形成的輸入錯誤。

var app = express();

app.route('/events')
.all(function(req, res, next) {
  // runs for all HTTP verbs first
  // think of it as route specific middleware!
})
.get(function(req, res, next) {
  res.json(...);
})
.post(function(req, res, next) {
  // maybe add a new event...
});

`app.set(name,value)`

設置setting中的屬性name的值爲value。

前面已經提到過，調用app.set('foo',true)設置布爾值爲true與使用app.enable('foo')相同，相似的，調用app.set('foo',false)與app.disable('foo')相同。

使用app.get能夠獲取設定的值。

app.set('title', 'My Site');
app.get('title'); // "My Site"

應用設定

下表列出了app setting的可選項

注意sub-app具備如下特徵：

不會繼承具備默認值的settings的值，其值必須在sub-app中設置；
會繼承沒有默認值的值，具體細節可見下表。

例外：

Sub-apps將繼承 trust proxy的值，儘管它有默認值，這樣作是出於向後兼容的目的；Sub-apps 在生產環境中不會繼承 view cache的值(當 NODE_ENV 設置爲 production)。

屬性	類型	描述	默認值
`case sensitive routing`	Boolean	啓用大小寫敏感，當啓用時，`/Foo`和`/foo`是不一樣的路由，當禁用時，`/Foo`和`/foo`將被看作同樣的，注意：Sub-app將繼承此值	`N/A(undefined)`
`env`	String	設置環境模式，請務必在生產環境中設置爲`production`;詳見 Production best practices: performance and reliability.	`process.env.NODE_ENV`(Node_ENV環境變量)或若是`NODE_ENV`沒有設置則爲`development`
`etag`	Varied	設置`Etag`響應頭。可選值可參考options table，更多關於Etag能夠參考維基百科--Etag	weak
`jsonp callback name`	String	指定默認的JSONP的回調名稱	"callback"
`json escape`	Boolean	對來自`res.josn`,`res.josnp`以及`res.send`的JSON響應啓用轉義，會轉義JSON中的`<`,`>`,`&`爲Unicode。此設置的目的在於當響應來自HTML的響應時協助緩解某些類型的持續XSS攻擊。注意：sub-app將繼承此值的設置	`N/A(undefined)`
`josn replacer`	Varied	指定`JSON.stringly`使用的`replacer`參數注意：Sub-app將繼承此值在setting中的設置	`N/A(undefined)`
`json spaces`	Varied	指定`JSON.stringly`使用的`space`參數，此值被用來設置用於美化縮進的空格數量，注意：`Sub-app`將繼承此值	`N/A(undefined)`
`query parser`	Varied	設置該值爲`false`將禁用`query`解析，也能夠設置其值爲`simple`或`extended` 或者一個自定義的查詢字符串解析函數。最簡單的query parser是基於Node的原生query parser`querystring` ，拓展的query parser基於`qs`。自定義的查詢字符串解析函數將接收完整的查詢字符串，而且必須返回一個有查詢名和它們的值組成的對象	"extended"
`strict routing`	Boolean	啓用嚴格路由模式，當啓用時，路由將視`/foo`和`/foo/`爲不一樣的路由。不然設爲相同的路由注意： Sub-app將繼承此設置	`N/A (undefined)`
`subdomain offset`	Number	爲了獲取子域名須要移除的由點隔開的部分	2
`trust proxy`	Varied	只是應用程序位於前置代理以後，使用`X-Forwarded-`請求頭來肯定客戶端的IP地址及鏈接，注：`X-Forwarded- `標頭容易僞造，檢測到的IP地址不可靠。啓用後，Express會嘗試肯定經過前置代理或一系列代理鏈接的客戶端的IP地址，`req.ips`屬性將包含鏈接的客戶端的IP地址組成的數組。要啓用它，能夠查看trust proxy options table;`trust proxy`的設置使用了proxy-addr包，能夠查看其文檔瞭解更多內容。注：儘管包含默認值，sub-apps會繼承其值	`false(disabled)`
`views`	String/Array	供程序視圖使用的一個或一組文件夾，若是是一個文件夾，將按照數組值的順序查找	`process.ced() + '/views'`
`view cache`	Boolean	啓用視圖模板彙編緩存，注：Sub-apps不會繼承此值在生產環境中的設置(當`NODE_ENV`設置爲`producetion`時爲生產環節)。	生產環境上默認爲`true`，不然爲`undefined`
`view engine`	String	默認的視圖處理引擎注：Sub-app將繼承此值的設置	`N/A(undefined)`
`x-powered-by`	Boolean	啓用`X-Powered-By:Express` HTTP 頭部	`true`

`trust proxy`的可用設置值

參考Express behind proxies可獲取更多的信息。

類型	值
`Boolean`	若是設置爲`true`,客戶端的IP地址將被認爲是`X-Forwarded- *`頭中最左邊的條目，若是設置爲`false`,後端應用被認爲直接與互聯網鏈接，併入客戶端的`IP`地址能夠從`req.connection.remoteAddress`中獲取，這也是默認的設置。
字符串/逗號分隔的字符串/字符串構成的數組	一個IP地址，`subnet`或者一組IP地址和一組可信任的子網的組合，下面展現了預配置的子網名稱： `loopback - 127.0.0.1/8, ::1/128`,`linklocal - 169.254.0.0/16, fe80::/10`,`uniquelocal - 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, fc00::/7`,你能夠用下列方法設置IP地址,指定單一的子網 `app.set('trust proxy', 'loopback')` ,指定一個子網及地址`app.set('trust proxy', 'loopback, 123.123.123.123')` ,指定多個子網爲CSV,`app.set('trust proxy', 'loopback, linklocal, uniquelocal')` ,經過數組格式指定多個子網`app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal'])`,指定時，將從地址肯定過程當中排除IP地址或子網，並將離應用程序服務器最近的不可信IP地址肯定爲客戶端的IP地址。
`Number`	信任從前置代理服務器做爲客戶端的第nth hop。
`Function`	自定義代理實現，只有當你知道你在作啥的時候才應該作這一步,實例以下

app.set('trust proxy', function (ip) {
  if (ip === '127.0.0.1' || ip === '123.123.123.123') return true; // trusted IPs
  else return false;
});

`etag`選項的配置

注意: 這些設置只適用於動態生成的文件而不適用於靜態文件， express.static中間件將忽略這些設置。
ETag功能是使用etag庫實現的。有關更多信息，可參閱其文檔。

類型	值
`Boolean`	設置爲`true`將容許`weak Etag`,這是默認的設置，設置爲`false`將禁用`Etag`
`String`	設置爲`strong`,將容許`strong Etag`,設置爲`weak`,將容許`weak Etag`
`Function`	自定義代理實現，只有當你知道你在作啥的時候才應該作這一步,實例以下

app.set('etag', function (body, encoding) {
  return generateHash(body, encoding); // consider the function is defined
});

`app.use([path],callback[,callback])`

爲指定的路徑指定中間件函數，當請求的路徑與之匹配時，中間件函數將會被執行。

參數

參數1： path 默認值： /(root path)

描述：

路徑模式能夠是如下類型中的一種：
- 路徑字符串
- 匹配路徑的正則表達式
- 通配符
- 上述類型值組成的數組
點擊Path examples可查看更多實際的例子

參數2： callback 默認值： None

描述：

回調函數能夠是以下類型中的一種：
- 一箇中間件函數
- 由逗號隔開的一系列中間件函數
- 一個由中間件函數構成的數組
- 上述狀況的組合
能夠提供多個回調函數，多個回調函數的調用與多箇中間件的調用相似，不一樣之處在於在回調函數中調用next（'route'）可繞過以後的回調函數。你能夠基於此機制來以爲是否須要觸發以後的回調函數

router和app都實現了中間件接口，你能夠像使用中間件同樣使用它們。

可在此處參考示例

描述

將會匹配任何當前路徑的子路徑，如app.use('/apple',...)將匹配/apple,/apple/images,/apple/images/news等等。

path默認的值是/，若是不設置路徑，所用中間件將響應每個請求。

好比說下述中間件函數將響應每個請求

app.use(function (req, res, next) {
  console.log('Time: %d', Date.now());
  next();
});

請注意sub-app具備如下特徵：

不會繼承具備默認值的settings的值，其值必須在sub-app中設置；

會繼承沒有默認值的值，這些會在下表中明確提到。

中間件函數將會按照順序執行，所以中間件的順序很是重要。

// 請求不會超出下面的中間件
app.use(function(req, res, next) {
  res.send('Hello World');
});

// 請求永遠不會到達下面的路由
app.get('/', function (req, res) {
  res.send('Welcome');
});

錯誤處理中間件

錯誤處理中間件須要接受四個參數，使用時必須傳入四個參數以證實當前中間件時錯誤處理中間件。這四個參數中包含next,即便你用不上next,也須要在參數中包含它，這樣才能知足錯誤處理中間件的函數簽名。簽名不對當前中間件會被當作普通的中間件使用而失去處理錯誤的能力。關於錯誤處理中間件的詳細信息能夠參考這裏。

除了必須接受四個參數，錯誤處理中間件的定義和普通中間件同樣，其函數簽名固定爲(err,req,res,next)

app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

路徑寫法示例

下表是一些有效的路徑示例

type: path:
示例：

將匹配以/abcd開頭的路徑：

app.use('/abcd', function (req, res, next) {
  next();
});

type: 路徑通配符

// 下述將匹配以'/abcd'和'/abd'開頭的路徑
app.use('/abc?d', function (req, res, next) {
  next();
});

// 下例將匹配以'/abcd','/abbcd','/abbbbbcd'等開頭的路徑
app.use('/ab+cd', function (req, res, next) {
  next();
});

// 下例將匹配以 '/abcd','/abxcd','/abFOOcd','/abbArcd'等開頭的路徑
app.use('/ab\*cd', function (req, res, next) {
  next();
});

// 下例將匹配 '/ab' 或 '/abcd'開頭的路徑

app.use('/a(bc)?d', function (req, res, next) {
  next();
});

type: 正則表達式

// 下例將匹配以'/abc','/xyz'開頭的路徑
app.use(/\/abc|\/xyz/, function (req, res, next) {
  next();
});

type: 數組

// 下例將匹配以'/abcd','/xyza','/lmn','/pqr'開頭的路徑
app.use(['/abcd', '/xyza', /\/lmn|\/pqr/], function (req, res, next) {
  next();
});

中間件回調函數示例

下面的示例展現了app.use(),app.METHOD(),app.all()中中間件函數的使用方法。

單箇中間件

// 可用直接寫中間件函數
app.use(function (req, res, next) {
  next();
});

// router也是一個有效的中間件
var router = express.Router();
router.get('/', function (req, res, next) {
  next();
});
app.use(router);

// Express app也是一個有效的中間件
var subApp = express();
subApp.get('/', function (req, res, next) {
  next();
});
app.use(subApp);

一系列的中間件

// 針對同一個路徑可用指定多箇中間件
var r1 = express.Router();
r1.get('/', function (req, res, next) {
  next();
});

var r2 = express.Router();
r2.get('/', function (req, res, next) {
  next();
});

app.use(r1, r2);

數組

// 可傳入一箇中間件數組，若是中間件數組是第一個或者惟一的一個參數，則你必須指定中間件匹配的路徑

var r1 = express.Router();
r1.get('/', function (req, res, next) {
  next();
});

var r2 = express.Router();
r2.get('/', function (req, res, next) {
  next();
});

app.use('/', [r1, r2]);

組合

// 你能夠組合使用上述全部的中間件
function mw1(req, res, next) { next(); }
function mw2(req, res, next) { next(); }

var r1 = express.Router();
r1.get('/', function (req, res, next) { next(); });

var r2 = express.Router();
r2.get('/', function (req, res, next) { next(); });

var subApp = express();
subApp.get('/', function (req, res, next) { next(); });

app.use(mw1, [mw2, r1, r2], subApp);

下面是一些在Express App中使用express.static中間件的示例。

// 把應用目錄下的`public`文件夾中的內容做爲靜態內容的方法
// GET /style.css etc
app.use(express.static(__dirname + '/public'));

// 匹配 以/static開頭的路徑以提供靜態內容
app.use('/static', express.static(__dirname + '/public'));

// 經過把logger中間件放在靜態中間件以後使得請求靜態內容時不logging
app.use(express.static(__dirname + '/public'));
app.use(logger());

// 從多個目錄中提供靜態文件，不過優先使用`./public`中的內容
app.use(express.static(__dirname + '/public'));
app.use(express.static(__dirname + '/files'));
app.use(express.static(__dirname + '/uploads'));

`Request`

req對象表明的是http請求，該對象中包含由請求而來的query,參數，body,HTTP headers等解析而來的屬性。按照慣例（此文檔也是如此）請求對象會記爲req(HTTP響應對象記爲res),不過這個名字具體是什麼仍是依據回調函數中的定義。

好比:

app.get('/user/:id', function(req, res) {
  res.send('user ' + req.params.id);
});

一樣，你也能夠按照下面這樣作：

app.get('/user/:id', function(request, response) {
  response.send('user ' + request.params.id);
});

req對象是node自己的請求對象的加強版，而且支持全部的內置字段和方法.

屬性

在Express4中， req.files默認再也不存在於 req對象中，你須要使用相似 busboy, multer, formidable, multiparty, connect-multiparty, pez這樣的多部件處理中間件來在經過 req.files獲取到上傳文件的信息。

`req.app`

此屬性指向使用當前中間件的Express application。

若是你遵守如下模式，在一個模塊中導出一箇中間件而後在主文件中require()這個中間件，則能夠在中間件中經過req.app獲取到當前的Express實例。

好比：

//index.js
app.get('/viewdirectory', require('./mymiddleware.js'))

//mymiddleware.js
module.exports = function (req, res) {
  res.send('The views directory is ' + req.app.get('views'));
});

`req.baseUrl`

獲取一個路由器實例所匹配的路徑。

req.baseUrl屬性和app對象的mountpath屬性相似，不一樣的地方在於app. mountpath返回的是匹配的路徑模式。

好比：

var greet = express.Router();

greet.get('/jp', function (req, res) {
  console.log(req.baseUrl); // /greet
  res.send('Konichiwa!');
});

app.use('/greet', greet); // load the router on '/greet'

即便你使用的是路徑通配符或者一組路徑模式來匹配路由，baseUrl屬性返回的也是匹配的字符串而非模式自己，如：

app.use(['/gre+t', '/hel{2}o'], greet); // load the router on '/gre+t' and '/hel{2}o'

當請求的路徑爲/greet/ip時，req.baseUrl的值爲/greet,當請求的路徑爲/hello/jp時，req.baseUrl爲/hello。

`req.body`

包含從request body中提交而來的鍵值對形式的數據。默認狀況下，req.body的值爲undefined,你須要使用如body-parser或multer這類body解析中間件來爲其填充內容。

下例展現瞭如何使用body解析中間件來擴充req.body中的內容：

var app = require('express')();
var bodyParser = require('body-parser');
var multer = require('multer'); // v1.0.5
var upload = multer(); // for parsing multipart/form-data

app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded

app.post('/profile', upload.array(), function (req, res, next) {
  console.log(req.body);
  res.json(req.body);
});

`req.cookies`

當使用cookie-parser中間件時，此屬性是一個由請求中的cookie信息構建的對象。若是請求中沒有cookie，其值爲{}。

// Cookie: name=tj
req.cookies.name
// => "tj"

若是cookie有簽名，則須要使用req.signedCookies.

可參照cookie-parser查看更多信息。

`req.fresh`

用以表徵當前請求是否「新鮮」，與req.stale相反。

若是cache-control請求頭不是no-cache而且下面的每一項的值都不是true,則它的值爲true.

if-modified-since請求頭是指定的，而且last-modified請求頭等於或者早於modified響應頭
if-none-match請求頭爲*;
if-none-match請求頭在被解析爲指令後，不匹配etag響應頭

req.fresh
// => true

更多信息可查看fresh

`req.hostname`

用以表徵從HTTP header派生出來的主機名。

當trust proxy 不等於false時，此屬性將使用X-Forwarded-Hostheader中的值，此值能夠經過客戶端或者代理設置。

// Host: "example.com:3000"
req.hostname
// => "example.com"

`req.ip`

用以表徵請求的遠程ip。

當trust proxy不爲false時，此值將取自X-Forwarded-For header.最左側，此請求頭能夠被客戶端或者代理設置。

req.ip
// => "127.0.0.1"

`req.ips`

當trust proxy 不等於false時，此屬性將使用X-Forwarded-Host header中指定的一組IP地址。或者將包含一個空數組，此請求頭能夠被客戶端或者代理設置。

好比說，若是X-Forwarded-For爲client, proxy1, proxy2,req.ips將會是["client", "proxy1", "proxy2"]，而proxy2是最下游的。

`req.method`

包含一個對應於當前請求方法的字符串，如GET,POST,PUT等等。

`req.originalUrl`

req.url並不是原生的Express屬性，其繼承自Node的http模塊。

此屬性很是相似於req.url，不一樣之處在於，它保留了原始請求URL，容許你爲內部路由重寫req.url。好比說，可使用app.use()的mounting功能來重寫req.url以去除掛載點。

// GET /search?q=something
req.originalUrl
// => "/search?q=something"

在中間件函數中，req.originalUrl是req.baseUrl和req.path的組合，以下所示：

app.use('/admin', function(req, res, next) {  // GET 'http://www.example.com/admin/new'
  console.log(req.originalUrl); // '/admin/new'
  console.log(req.baseUrl); // '/admin'
  console.log(req.path); // '/new'
  next();
});

`req.params`

此屬性是一個映射到命名路由參數的對象。好比你的路由爲/user/:name,那麼能夠經過req.params.name獲取到name屬性的值，此對象默認值爲{}。

// GET /user/tj
req.params.name
// => "tj"

當你的路由定義使用的是正則表達式時，可使用req.params[n]來獲取捕獲組的值，其中n是第n個捕獲組,此規則也適用於未命名的通配符與字符串路由（如/file/*）的匹配：

// GET /file/javascripts/jquery.js
req.params[0]
// => "javascripts/jquery.js"

若是你須要對req.params中的鍵作改變，可使用app.param處理器，更改僅適用於已經在路徑中定義的參數。

在中間件或路由處理函數中對req.params對象所作的任何更改都將被重置。

注： Express會自動依據（ decodeURIComponent）解碼 req.params中的值。

`req.path`

表示請求URL的路徑部分。

// example.com/users?sort=desc
req.path
// => "/users"

從中間件調用時，掛載點不包含在 req.path中。有關更多詳細信息，請參閱 app.use()。

`req.protocol`

表徵請求協議的字符串，多是http或https。

當trust proxy 不等於false時，此屬性將使用X-Forwarded-Hostheader中的值，此值能夠經過客戶端或者代理設置。

req.protocol
// => "http"

`req.query`

此屬性經過解析查詢字符串而生產的對象。若是沒有查詢字符串，則爲空對象{}。

// GET /search?q=tobi+ferret
req.query.q
// => "tobi ferret"

// GET /shoes?order=desc&shoe[color]=blue&shoe[type]=converse
req.query.order
// => "desc"

req.query.shoe.color
// => "blue"

req.query.shoe.type
// => "converse"

`req.route`

返回一個對象，表示當前匹配的路由，好比：

app.get('/user/:id?', function userIdHandler(req, res) {
  console.log(req.route);
  res.send('GET');
});

上述代碼片斷的輸出結果以下：

{ path: '/user/:id?',
  stack:
   [ { handle: [Function: userIdHandler],
       name: 'userIdHandler',
       params: undefined,
       path: undefined,
       keys: [],
       regexp: /^\/?$/i,
       method: 'get' } ],
  methods: { get: true } }

`req.secure`

表徵TLS鏈接是否創建的布爾值，等同於:

'https' == req.protocol;

`req.signedCookies`

當使用了cookie-parser中間件時，此屬性包含請求帶來的簽名cookies，普通的cookie可經過req.cookie訪問，可是容易被僞造存在惡意攻擊的風險，簽名cookie實際上並不會使cookie被加密或者隱藏，可是會使得它難以被篡改（用於簽名的secret是私密的）。

若是沒有簽名cookie，此屬性的值爲{}。

// Cookie: user=tobi.CP7AWaXDfAKIRfH49dQzKJx7sKzzSoPq7/AcBBRVwlI3
req.signedCookies.user
// => "tobi"

更多信息可查看cookie-parser中間件。

`req.stale`

表徵此請求是不是過期，此屬性是req.fresh的對立面。更多信息可查看req.fresh.

req.stale
// => true

`req.subdomains`

表徵請求域名的子域名構成的數組。

// Host: "tobi.ferrets.example.com"
req.subdomains
// => ["ferrets", "tobi"]

app settings 中 subdomain offset 的默認值爲2,此值能夠用來肯定子域名的起始位置。可經過app.set()來改變默認值。

`req.xhr`

是一個布爾值，若是請求頭的X-Requested-With爲XMLHttpRequest,則爲true,代表該請求由一個相似jQuery的客戶端庫發起。

req.xhr
// => true

Methods

`req.accepts(types)`

檢測指定的內容類型是否被接受，結果基於HTTP中的Accept請求頭。此方法返回最佳匹配值，若是都不匹配則返回false,這種狀況下，應用的狀態碼應該爲406 Not Acceptable。

type的值能夠是單個的MIME類型字符串（好比說application/json），能夠是拓展名如json,能夠是由逗號分隔的列表，或者一個數組。若是是列表或者數組，則返回最佳的匹配值。

// Accept: text/html
req.accepts('html');
// => "html"

// Accept: text/*, application/json
req.accepts('html');
// => "html"
req.accepts('text/html');
// => "text/html"
req.accepts(['json', 'text']);
// => "json"
req.accepts('application/json');
// => "application/json"

// Accept: text/*, application/json
req.accepts('image/png');
req.accepts('png');
// => undefined

// Accept: text/*;q=.5, application/json
req.accepts(['html', 'json']);
// => "json"

查看accepts可瞭解更多信息。

`req.acceptsCharsets(charset[,...])`

返回指定的字符集中第一個匹配的字符集，此結果基於Accept-Charset請求頭，若是指定的字符集都不被承認則返回false.

查看accepts可瞭解更多信息。

`req.acceptsEncodings(encoding [, ...])`

返回指定的編碼集中的第一個匹配的編碼，結果基於Accept-Encoding請求頭，若是都不匹配則返回false.

查看accepts可瞭解更多信息。

`req.acceptsLanguages(lang [, ...])`

返回匹配到的第一種語言，結果技術Accept-Language請求頭。若是都不匹配則返回false.

查看accepts可瞭解更多信息。

`req.get(field)`

獲取請求頭中對應項的值（大小寫不敏感），Referrer和Referer是通用的。

req.get('Content-Type');
// => "text/plain"

req.get('content-type');
// => "text/plain"

req.get('Something');
// => undefined

結果和req.header(filed)一致。

`req.is(type)`

若是傳入請求的「Content-Type」HTTP頭字段與type參數指定的MIME類型匹配，則返回匹配的內容類型。不然返回false。

// With Content-Type: text/html; charset=utf-8
req.is('html');       // => 'html'
req.is('text/html');  // => 'text/html'
req.is('text/*');     // => 'text/*'

// When Content-Type is application/json
req.is('json');              // => 'json'
req.is('application/json');  // => 'application/json'
req.is('application/*');     // => 'application/*'

req.is('html');
// => false

可參看type-is瞭解更多信息。

`req.param(name [, defaultValue])`

已棄用，請使用 req.params,req.body.req.query。

`req.range(size[, options])`

此 api還不算理解

規範頭解析器。

size參數表示資源的最大值。

options是一個可包含以下值得對象：

屬性	類型	描述
`combine`	布爾值	指示重疊或者相鄰的域是否該合併，默認爲`false`,當設置爲`true`時，域將被合併返回就相似自己他們在header中是這樣表示的同樣

此方法會返回一個數組表明成功或者一個負數表示錯誤的解析

-2 表示格式錯誤的頭部字符串
-1 表示不知足範圍

// parse header from request
var range = req.range(1000)

// the type of the range
if (range.type === 'bytes') {
  // the ranges
  range.forEach(function (r) {
    // do something with r.start and r.end
  })
}

`Response`

res對象表明的是當Express app 接收 HTTP 請求時發送的 HTTP 響應。通常說來此對象會被命名爲res(相應請求對象是req)，不過其命名其實是由回調函數中的參數肯定的。

好比說你能夠這樣作：

app.get('/user/:id', function(req, res){
  res.send('user ' + req.params.id);
});

也能夠這樣作：

app.get('/user/:id', function(request, response){
  response.send('user ' + request.params.id);
});

res對象是Node內置的response對象的增強版而且支持其全部的內置方法。

屬性

`res.app`

指向使用該中間件的express實例，在請求對象中 req.app 和 res.app同樣。

`res.headersSent`

是一個布爾值，指示app是否爲響應發送了HTTP headers。

app.get('/', function (req, res) {
  console.log(res.headersSent); // false
  res.send('OK');
  console.log(res.headersSent); // true
});

`res.locals`

表示包含在請求生命週期內的本地變量。除了在請求/響應過程當中視圖渲染時可用，其他和 app.locals 功能同樣。

這個屬性在暴露請求層面的信息時很是有用，好比路徑名, 受權用戶, 用戶設置等等。

app.use(function(req, res, next){
  res.locals.user = req.user;
  res.locals.authenticated = ! req.user.anonymous;
  next();
});

方法

`res.append(field[,value])`

在Express4.11.0以上版本中被支持。

添加指定值到HTTP響應頭中，若是header不存在，則依據指定的值建立該頭，值能夠是字符串或者數組。

注意：在res.append()後面調用res.set()將覆蓋前面設置的值。

res.append('Link', ['<http://localhost/>', '<http://localhost:3000/>']);
res.append('Set-Cookie', 'foo=bar; Path=/; HttpOnly');
res.append('Warning', '199 Miscellaneous warning');

`res.attachment([filename])`

設置HTTP響應頭Content-Disposition爲attachment,若是指定了filename,則會依據filename的後綴經過res.type()設置Content-Type,同時會設置Content-Disposition 「filename=」部分：

res.attachment();
// Content-Disposition: attachment

res.attachment('path/to/logo.png');
// Content-Disposition: attachment; filename="logo.png"
// Content-Type: image/png

`res.cookie(name, value [, options])`

設置cookie name的值爲value。 value的值能夠是一個字符串或者轉換爲json的對象。

options 參數是一個能夠擁有如下屬性的參數。

Property	Type	Description
domain	String	設置 cookie 的域名,默認爲 app 的域名
encode	Function	用於編碼 cookie 的函數，默認爲`encodeURIComponent`
expires	Date	GMT 格式的時間，用以表示cookie的過時時間. 若是沒有指定，則生成一個session cookie
httpOnly	Boolean	標記該cookie只能在服務器端可用
maxAge	Number	已ms格式設置的cookie過時時間
path	String	cookie的路徑，默認爲`/`
secure	Boolean	指示該cookie只有在https狀況下可用
signed	Boolean	指示該cookie是否應該被簽名
sameSite	Boolean or String	「SameSite」 Set-Cookie 熟悉. 更多信息可參考這裏

res.cookie()作的事情其實就是設置了 Set-Cookie頭中對應的信息。

使用示例以下：

res.cookie('name', 'tobi', { domain: '.example.com', path: '/admin', secure: true });
res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });

encode值是一個函數，用於指定cookie的編碼格式，不支持異步函數。

示例以下：

//Default encoding
res.cookie('some_cross_domain_cookie', 'http://mysubdomain.example.com',{domain:'example.com'});
// Result: 'some_cross_domain_cookie=http%3A%2F%2Fmysubdomain.example.com; Domain=example.com; Path=/'

//Custom encoding
res.cookie('some_cross_domain_cookie', 'http://mysubdomain.example.com',{domain:'example.com', encode: String});
// Result: 'some_cross_domain_cookie=http://mysubdomain.example.com; Domain=example.com; Path=/;'

maxAge是一種更爲方便的設置過時時間的方法，以下:

res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true });

cookie的值也能夠是一個對象，其以後會被bodyParser()序列化爲JSON。

res.cookie('cart', { items: [1,2,3] });
res.cookie('cart', { items: [1,2,3] }, { maxAge: 900000 });

當使用cookie-parser中間件時，此方法一樣支持簽名cookie，只須要設置signed爲true,res.cookie()就會利用傳輸給cookieParser(secret)的secret對該值進行簽名。

res.cookie('name', 'tobi', { signed: true });

以後你能夠經過req.signedCookie讀取簽名的cookie值。

`res.clearCookie(name[,options])`

清除名稱爲name的cookie。

瀏覽器等客戶端只會清除到達過時時間的cookie。

res.cookie('name', 'tobi', { path: '/admin' });
res.clearCookie('name', { path: '/admin' });

`res.download(path [, filename] [, options] [, fn])`

此方法中的參數 options只在 v4.16.0以後的版本中可用。

已附件在路徑中傳輸文件，通常說來，瀏覽器會提示用戶下載文件，默認狀況下 Content-Disposition header 中的 filename= 參數就是路徑（此值通常會出如今瀏覽器的對話框中）。使用filename參數可用覆蓋此值。傳輸出錯或者下載完成會調用回調函數fn。此方法使用res.sendFile()來傳送文件。

可選的options參數傳遞給底層的res.sendFile()調用，並採用與其徹底相同的參數。

res.download('/report-12345.pdf');

res.download('/report-12345.pdf', 'report.pdf');

res.download('/report-12345.pdf', 'report.pdf', function(err){
  if (err) {
    // Handle error, but keep in mind the response may be partially-sent
    // so check res.headersSent
  } else {
    // decrement a download credit, etc.
  }
});

`res.end([data] [, encoding])`

用於結束響應過程，此方法來自node核心，http.ServerResponse 模塊中的 response.end().用於不傳輸任何數據快速結束響應，若是你想要傳輸數據，請使用res.send()或者res.json()

res.end();
res.status(404).end();

`res.format(object)`

若是請求對象中存在的Accept HTTP頭，可觸發內容協商，將使用req.accepts()值的權重爲選擇請求對應的處理器，若是請求的Accept請求頭沒有被指定，將觸發第一個回調函數，當沒有匹配值時，服務器會返回406 「Not Acceptable」，或者觸發默認的回調函數。

當回調函數被選定時，響應頭的Content-Type將會被自動設定，固然在回調函數中你也可使用res.set() 或者 res.type()來更改此請求頭的值。

下例中，當Accept頭設置爲「application/json」或「*/json」時響應爲{ "message": "hey" },(若是Accept頭設置爲*/*,響應爲hey)。

res.format({
  'text/plain': function(){
    res.send('hey');
  },

  'text/html': function(){
    res.send('<p>hey</p>');
  },

  'application/json': function(){
    res.send({ message: 'hey' });
  },

  'default': function() {
    // log the request and respond with 406
    res.status(406).send('Not Acceptable');
  }
});

除了指定規範化的 MIME 類型，還可使用拓展名來映射，來簡化上述語句:

res.format({
  text: function(){
    res.send('hey');
  },

  html: function(){
    res.send('<p>hey</p>');
  },

  json: function(){
    res.send({ message: 'hey' });
  }
});

`res.get(field)`

依據指定的field,返回指定的HTTP 響應頭對應的值，field大小寫不敏感。

res.get('Content-Type');
// => "text/plain"

`res.json([body])`

發送一個JSON響應，此方法將使用正常的內容類型發送響應，參數將經過JSON.stringify()轉換爲JSON字符串。

參數能夠是任何JSON類型，包括對象，數組，字符串，布爾值，數值等等，你也可使用它轉換其它值爲JSON，好比說null,undefined(雖然這些類型從技術上來說不是有效的JSON)。

res.json(null);
res.json({ user: 'tobi' });
res.status(500).json({ error: 'message' });

`res.jsonp([body])`

使用JSONP發送JSON響應，除了支持JSONP回調，此方法與res.json()相同。

res.jsonp(null);
// => callback(null)

res.jsonp({ user: 'tobi' });
// => callback({ "user": "tobi" })

res.status(500).jsonp({ error: 'message' });
// => callback({ "error": "message" })

默認狀況下，JSONP的回調函數名稱爲callback,能夠經過設置jsonp callback name來更換。

如下是JSONP的一些使用示例：

// ?callback=foo
res.jsonp({ user: 'tobi' });
// => foo({ "user": "tobi" })

app.set('jsonp callback name', 'cb');

// ?cb=foo
res.status(500).jsonp({ error: 'message' });
// => foo({ "error": "message" })

`res.links(links)`

把參數添加到HTTP 響應頭 Link 中。

以下例:

res.links({
  next: 'http://api.example.com/users?page=2',
  last: 'http://api.example.com/users?page=5'
});

將獲得如下結果;

Link: <http://api.example.com/users?page=2>; rel="next",
      <http://api.example.com/users?page=5>; rel="last"

`res.location(path)`

設置響應頭Location爲指定的值：

res.location('/foo/bar');
res.location('http://example.com');
res.location('back');

值back具備特殊的含義，它指向請求頭中的Referer頭的值，若是請求頭中Referer沒有被指定，響應頭中的Location將指向/。

若是沒有編碼，在進行編碼後，Express將經過頭 Location傳遞指定的URL到瀏覽器中，這個過程不會有任何驗證。
瀏覽器負責從當前URL或引用UR以及 location中指定的URL獲取預期的URL，並相應的進行重定向。

`res.redirect([status,] path)`

依據指定的路徑和狀態（一個對應於HTTP狀態碼的正整數）重定向URL，若是沒有指定，默認值爲302 Found。

res.redirect('/foo/bar');
res.redirect('http://example.com');
res.redirect(301, 'http://example.com');
res.redirect('../login');

能夠傳入一個完整的站點信息重定向到其它的網站

res.redirect('http://google.com');

重定向也能夠相對域名全部的root發生，好比說，若是當前位置位於http://example.com/admin/post/new,下述代碼將重定向至http://example.com/admin。

res.redirect('/admin');

重定向也能夠相對於當前的URL，好比下面的例子中將從http://example.com/blog/admin/重定向至http://example.com/blog/admin/post/new。

res.redirect('post/new');

若是從http://example.com/blog/admin重定向至post/new將重定向至http://example.com/blog/post/new.

能夠把 /這個過程理解,這樣能讓你的思路更爲清晰。

若是傳入的值爲back,將重定向至referer請求頭,若是referer不存在則默認爲/。

res.redirect('back');

`res.render(view [, locals] [, callback])`

渲染視圖併發送渲染獲得的html字符串到客戶端。可選參數以下：

locals:一個定義了視圖函數中可用的本地變量組成的對象；
callback:一個回調函數。若是提供，該方法返回可能的錯誤和呈現的字符串，但不會執行自動響應。發生錯誤時，該方法會在內部調用next(err)。

view參數是一個字符串，指向視圖文件的位置。此值能夠是決定路徑也能夠是相對views setting的相對路徑，若是該路徑不包含拓展名則view engine的設置會決定其拓展名，若是包含拓展名將以指定的模板引擎渲染模塊（使用require），並將觸發對應模塊的__express方法來進行渲染。更多信息可見在Express中使用模板引擎。

view參數執行文件系統操做，如從磁盤讀取文件和評估Node.js模塊，所以出於安全考慮，不該包含來自最終用戶的輸入。

// send the rendered view to the client
res.render('index');

// if a callback is specified, the rendered HTML string has to be sent explicitly
res.render('index', function(err, html) {
  res.send(html);
});

// pass a local variable to the view
res.render('user', { name: 'Tobi' }, function(err, html) {
  // ...
});

`res.send([body])`

發送Http響應，

body參數能夠是Buffer object, a String, an object, or an Array.

如：

res.send(new Buffer('whoop'));
res.send({ some: 'json' });
res.send('<p>some html</p>');
res.status(404).send('Sorry, we cannot find that!');
res.status(500).send({ error: 'something blew up' });

此方法爲非流式響應提供了一些自動操做，如自動添加Content-Length響應頭，而且自動添加HEAD以及HTTP緩存。

當參數爲Buffer對象時，此方法設置Content-Type響應頭爲application/octet-stream,除非像下面這樣預先定義：

res.set('Content-Type', 'text/html');
res.send(new Buffer('<p>some html</p>'));

當參數爲String時，會自動設置Content-Type爲「text/html」

res.send('<p>some html</p>');

當響應爲對象或者數組時，響應值爲JSON表示：

res.send({ user: 'tobi' });
res.send([1,2,3]);

`res.sendFile(path [, options] [, fn])`

res.sendFile(path [, options] [, fn])在 Express4.8.0以後的版本中被支持。

基於給定的路徑傳輸文件，並依據文件的拓展名設置響應頭的Content-Type.除非在options對象中設置了root,否者路徑必須爲絕對路徑。

下表提供了options參數的詳細信息

| Property | Description | Default | Availability |
| -------- | ------------ | ------ | ------------|
| maxAge | 以毫秒格式設置Cache-Control響應頭中的max-age值，能夠是數值或者數值格式的字符串 | 0 | |
| root | 相對文件的Root路徑 | | |
| lastModified | 設置Last-Modified響應頭的值爲該文件在系統中最後被修改的日期，設置爲false 能夠禁用它 | Enabled | 4.9.0+ |
| headers | 包含HTTP頭文件的對象。| | |
| dotfiles | 是否提供點開頭的文件. 可選值有「allow」, 「deny」, 「ignore」. | 「ignore」 ||
| acceptRanges | 啓用或禁用接受範圍的請求。| true | 4.14+ |
| cacheControl | 啓用或者禁用設置 Cache-Control 響應頭 | true | 4.14+ |
| immutable | 啓用或者禁用響應頭中的Cache-Control 的immutable指示，若是啓用，maxAge應該指示爲可用。此指示會在maxAge生命週期內組織客戶端進行額外的請求|false |4.16+|

當傳輸完成或者出現錯誤時會觸發回調函數fn(err),若是指定了回調函數而且確實發生了錯誤，則回調函數必須處理響應過程，可中斷響應也可傳入控制到下一個route。

示例以下：

app.get('/file/:name', function (req, res, next) {

  var options = {
    root: __dirname + '/public/',
    dotfiles: 'deny',
    headers: {
        'x-timestamp': Date.now(),
        'x-sent': true
    }
  };

  var fileName = req.params.name;
  res.sendFile(fileName, options, function (err) {
    if (err) {
      next(err);
    } else {
      console.log('Sent:', fileName);
    }
  });

});

下面的例子展現了使用res.sendFile爲服務文件提供精細的控制:

app.get('/user/:uid/photos/:file', function(req, res){
  var uid = req.params.uid
    , file = req.params.file;

  req.user.mayViewFilesFrom(uid, function(yes){
    if (yes) {
      res.sendFile('/uploads/' + uid + '/' + file);
    } else {
      res.status(403).send("Sorry! You can't see that.");
    }
  });
});

更多信息能夠查看send。

`res.sendStatus(statusCode)`

設置HTTP響應的狀態碼爲statusCode,而且在響應body中添加它的字符串表示。

res.sendStatus(200); // equivalent to res.status(200).send('OK')
res.sendStatus(403); // equivalent to res.status(403).send('Forbidden')
res.sendStatus(404); // equivalent to res.status(404).send('Not Found')
res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')

若是指定了不受支持的狀態碼，該狀態碼依舊會被指定，響應信息會是該狀態碼的字符串表示。

res.sendStatus(2000); // equivalent to res.status(2000).send('2000')

關於狀態碼的更多信息

`res.set(field [, value])`

設置響應頭對應的field爲value,此方法也支持同時設置多個field爲對應的值。

res.set('Content-Type', 'text/plain');

res.set({
  'Content-Type': 'text/plain',
  'Content-Length': '123',
  'ETag': '12345'
});

此方法和res.header(field [, value]).功能一致。

`res.status(code)`

設置響應的HTTP狀態碼，它能夠看作一個可鏈式調用的response.statusCode。

res.status(403).end();
res.status(400).send('Bad Request');
res.status(404).sendFile('/absolute/path/to/404.png');

`res.type(type)`

設置Content-Type爲對應的MIME類型，若是type中包含/,將會設置Content-Type爲傳入的type。

res.type('.html');              // => 'text/html'
res.type('html');               // => 'text/html'
res.type('json');               // => 'application/json'
res.type('application/json');   // => 'application/json'
res.type('png');                // => image/png:

`res.vary(field)`

若是不存在添加該字段到Vary響應頭中。

res.vary('User-Agent').render('docs');

Router

router對象是一箇中間件或者路由的獨立實例，你能夠把它當作迷你程序，只能執行中間件和路由函數。每個Express程序都有一個內置的app路由。

路由器的行爲就像中間件自己同樣，因此你能夠用它做爲app.use()的參數，或者做爲另外一個路由器的use（）方法的參數。

頂層的express對象擁有一個Router()方法能夠用於建立一個router對象。

一旦建立了一個路由器對象，就能夠像應用程序同樣向其添加中間件和HTTP方法路由（例如get，put，post等）好比：

// invoked for any requests passed to this router
router.use(function(req, res, next) {
  // .. some logic here .. like any other middleware
  next();
});

// will handle any request that ends in /events
// depends on where the router is "use()'d"
router.get('/events', function(req, res, next) {
  // ..
});

你能夠爲特定的路徑指定路由，從而把對不一樣路由的處理分隔到不一樣的文件中。

// only requests to /calendar/* will be sent to our "router"
app.use('/calendar', router);

方法

`router.all(path, [callback, ...] callback)`

此方法相似標準的router.MEYHOD()方法，不一樣的地方在於它將匹配全部的http請求。

router.all('*', requireAuthentication, loadUser);

上述代碼也等同於

router.all('*', requireAuthentication);
router.all('*', loadUser);

下面還有另一個很是好用的全局函數示例，這個例子和上面那個相似，可是嚴格限制路徑以/api開頭

router.all('/api/*', requireAuthentication);

`router.METHOD(path, [callback, ...] callback)`

若是沒有在 router.get()前指定 HTTP HEAD對應的方法，將會調用 router.get()響應 HEAD請求。

你也能夠提供多個回調函數，他們會被同等的對待，而且像中間件同樣行爲，只不過這些回調可能會調用next（'route'）來繞過剩餘的路由回調。您可使用此機制在路由上執行預處理，而且在再也不須要在繼續處理時把控制權移交給下一個路由。

下面的例子展現了最簡單的路由定義，Express會將路徑字符串轉換爲正則表達式，用以匹配接收到的請求，匹配時不會考慮查詢字符串，好比GET /將會匹配GET /?name=tobi,以下所示：

router.get('/', function(req, res){
  res.send('hello world');
});

你一樣可使用正則表達式來進行匹配，這在你有特殊匹配時很是有用，好比說下面的路由將匹配GET /commits/71dbb9c和 GET /commits/71dbb9c..4c084f9

router.get(/^\/commits\/(\w+)(?:\.\.(\w+))?$/, function(req, res){
  var from = req.params[0];
  var to = req.params[1] || 'HEAD';
  res.send('commit range ' + from + '..' + to);
});

`router.param(name, callback)`

爲路由參數添加回調函數，其中name是參數名或參數組成的數組，callback是回調函數。回調函數的參數依次是請求對象(request)，響應對象(response),下一個中間件，參數值及參數名。

若是name是一個數組，回調函數會按照它們聲明的順序被註冊到其中的每一個值。此外除了最後一個聲明的參數，回調函數中的next將會觸發下一個註冊參數的回調函數，而對於最後一個參數，next則會調用處理當前路由的下一個中間件，此時的處理就像name只是一個字符串同樣。

好比說當:user存在於路由的路徑中時，你可能想映射用戶加載邏輯以自動提供req.user給路由或者對參數輸入執行驗證。

app.param('user', function(req, res, next, id) {

  // try to get the user details from the User model and attach it to the request object
  User.find(id, function(err, user) {
    if (err) {
      next(err);
    } else if (user) {
      req.user = user;
      next();
    } else {
      next(new Error('failed to load user'));
    }
  });
});

Param 回調函數對於它們定義的路由來講是本地的。它們不會被載入的app及router繼承。所以，定義在app上的參數回調只會被定義在app路由上的路由參數觸發。

全部的參數回調將會在任何匹配該路由的處理函數前觸發，而且在一個請求響應週期內只會被觸發一次，即便參數匹配了多個路由也是如此。

app.param('id', function (req, res, next, id) {
  console.log('CALLED ONLY ONCE');
  next();
});

app.get('/user/:id', function (req, res, next) {
  console.log('although this matches');
  next();
});

app.get('/user/:id', function (req, res) {
  console.log('and this matches too');
  res.end();
});

對於請求GET /user/42將打印如下語句：

CALLED ONLY ONCE
although this matches
and this matches too

app.param(['id', 'page'], function (req, res, next, value) {
  console.log('CALLED ONLY ONCE with', value);
  next();
});

app.get('/user/:id/:page', function (req, res, next) {
  console.log('although this matches');
  next();
});

app.get('/user/:id/:page', function (req, res) {
  console.log('and this matches too');
  res.end();
});

對於請求 GET /user/42/3,下面語句將被打印

CALLED ONLY ONCE with 42
CALLED ONLY ONCE with 3
although this matches
and this matches too

`router.route(path)`

返回單一路由的實例，你可使用不一樣的可選中間件來處理不一樣類型的請求。使用route.route()能夠避免重複的寫路由名及由此形成的輸入錯誤。

var router = express.Router();

router.param('user_id', function(req, res, next, id) {
  // sample user, would actually fetch from DB, etc...
  req.user = {
    id: id,
    name: 'TJ'
  };
  next();
});

router.route('/users/:user_id')
.all(function(req, res, next) {
  // runs for all HTTP verbs first
  // think of it as route specific middleware!
  next();
})
.get(function(req, res, next) {
  res.json(req.user);
})
.put(function(req, res, next) {
  // just an example of maybe updating the user
  req.user.name = req.params.name;
  // save user ... etc
  res.json(req.user);
})
.post(function(req, res, next) {
  next(new Error('not implemented'));
})
.delete(function(req, res, next) {
  next(new Error('not implemented'));
});

這種方法爲單一的路徑/users/:user_id添加了不一樣的 HTTP 方法。

`router.use([path], [function, ...] function)`

爲可選的path添加一系列的處理函數，path默認值爲/。

此方法相似於app.use(),下面是一個簡單的例子，能夠查看app.use查看更多信息。

中間件就像水暖管同樣，有請求時會從第一個匹配的中間件開始逐步往下到全部匹配到的中間件。

var express = require('express');
var app = express();
var router = express.Router();

// simple logger for this router's requests
// all requests to this router will first hit this middleware
router.use(function(req, res, next) {
  console.log('%s %s %s', req.method, req.url, req.path);
  next();
});

// this will only be invoked if the path starts with /bar from the mount point
router.use('/bar', function(req, res, next) {
  // ... maybe some additional /bar logging ...
  next();
});

// always invoked
router.use(function(req, res, next) {
  res.send('Hello World');
});

app.use('/foo', router);

app.listen(3000);

匹配的路徑被剝離而且對中間件函數不可見，此特性的意義在於一個匹配的中間件函數能夠獨立於路徑執行。

使用router.use()定義的中間件函數很是重要，它們會依次被觸發，好比說第一個中間件函數經常是logger,這樣全部的請求都會被log.

var logger = require('morgan');

router.use(logger());
router.use(express.static(__dirname + '/public'));
router.use(function(req, res){
  res.send('Hello');
});

假如如今你想忽略靜態文件的log,可是對其它的請求仍是想要有log,你只需把 express.static() 移動到logger中間件上面便可。

router.use(express.static(__dirname + '/public'));
router.use(logger());
router.use(function(req, res){
  res.send('Hello');
});

靜態服務器是另外一個很好的例子，假如你想給/public更高的權重，你能夠按照下面這樣進行：

app.use(express.static(__dirname + '/public'));
app.use(express.static(__dirname + '/files'));
app.use(express.static(__dirname + '/uploads'));

router.use()方法還支持命名參數，以便其餘路由器的掛載點可使用命名參數進行預加載。

注意：雖然這些中間件功能是經過一個特定的路由器添加的，可是當它們運行的時候是由它們所匹配的路徑（而不是路由器）來定義的。所以，若是路由匹配，經過一個路由器添加的中間件能夠運行其餘路由器。例如，這段代碼顯示了兩個不一樣的路由器匹配到了同一個路徑

var authRouter = express.Router();
var openRouter = express.Router();

authRouter.use(require('./authenticate').basic(usersdb));

authRouter.get('/:user_id/edit', function(req, res, next) { 
  // ... Edit user UI ...  
});
openRouter.get('/', function(req, res, next) { 
  // ... List users ... 
})
openRouter.get('/:user_id', function(req, res, next) { 
  // ... View user ... 
})

app.use('/users', authRouter);
app.use('/users', openRouter);

上面的例子中，雖然authenticate定義在了authRouter上，可是也會執行openRouter路由器關聯的中間件，爲了不這種行爲，最好不一樣的路由器不要匹配相同的路徑。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

Express4.x api 翻譯（draft）

express()

方法

express.json([options])

express.static(root,[options])

dotfiles

fallthrough

setHeaders

express.static使用示例

express.Router([options])

express.urlencoded([options])

Application

屬性

app.locals

app.mountpath

Events

app.on('mount',callback(parent))

Methods

app.all(path,callback[,callback])

參數

示例

app.delete(path, callback [, callback ...])

參數

示例

app.disable(name)

app.disabled(name)

app.enable(name)

app.enabled(name)

app.engine(ext,callback)

app.get(name)

app.get(path,callback[,callback])

參數

app.listen(path,[callback])

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

app.METHOD(path,callback[,callback])

參數

路由方法

app.param([name],callback)

app.path

app.post(path,callback[,callback])

參數

示例

app.put(path,callback[,callback])

參數

示例

app.render(view,[locals],callback)

app.route(path)

app.set(name,value)

應用設定

trust proxy的可用設置值

etag選項的配置

app.use([path],callback[,callback])

錯誤處理中間件

路徑寫法示例

中間件回調函數示例

Request

屬性

req.app

req.baseUrl

req.body

req.cookies

req.fresh

req.hostname

req.ip

req.ips

req.method

req.originalUrl

req.params

req.path

req.protocol

req.query

req.route

req.secure

req.signedCookies

req.stale

req.subdomains

req.xhr

Methods

req.accepts(types)

req.acceptsCharsets(charset[,...])

`express()`

`express.json([options])`

`express.static(root,[options])`

`express.static`使用示例

`express.Router([options])`

`express.urlencoded([options])`

`app.locals`

`app.mountpath`

`app.on('mount',callback(parent))`

`app.all(path,callback[,callback])`

`app.delete(path, callback [, callback ...])`

`app.disable(name)`

`app.disabled(name)`

`app.enable(name)`

`app.enabled(name)`

`app.engine(ext,callback)`

`app.get(name)`

`app.get(path,callback[,callback])`

`app.listen(path,[callback])`

`app.listen(port,[hostname],[backlog],[callback])`

`app.METHOD(path,callback[,callback])`

`app.param([name],callback)`

`app.path`

`app.post(path,callback[,callback])`

`app.put(path,callback[,callback])`

`app.render(view,[locals],callback)`

`app.route(path)`

`app.set(name,value)`

`trust proxy`的可用設置值

`etag`選項的配置

`app.use([path],callback[,callback])`

`Request`

`req.app`

`req.baseUrl`

`req.body`

`req.cookies`

`req.fresh`

`req.hostname`

`req.ip`

`req.ips`

`req.method`

`req.originalUrl`

`req.params`

`req.path`

`req.protocol`

`req.query`

`req.route`

`req.secure`

`req.signedCookies`

`req.stale`

`req.subdomains`

`req.xhr`

`req.accepts(types)`

`req.acceptsCharsets(charset[,...])`

`req.acceptsEncodings(encoding [, ...])`

`req.acceptsLanguages(lang [, ...])`

`req.get(field)`

`req.is(type)`

`req.param(name [, defaultValue])`

`req.range(size[, options])`

`Response`

`res.app`

`res.headersSent`

`res.locals`

`res.append(field[,value])`

`res.attachment([filename])`

`res.cookie(name, value [, options])`

`res.clearCookie(name[,options])`

`res.download(path [, filename] [, options] [, fn])`

`res.end([data] [, encoding])`

`res.format(object)`

`res.get(field)`

`res.json([body])`

`res.jsonp([body])`

`res.links(links)`

`res.location(path)`

`res.redirect([status,] path)`

`res.render(view [, locals] [, callback])`

`res.send([body])`

`res.sendFile(path [, options] [, fn])`