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

默认状况下，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])`