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。

它还具有影响应用程序行为的设置（属性）。有关更多信息，请参阅应用程序设置。
的Express应用程序对象可以从被称为请求对象和响应对象如req.app，和res.app分别。

属性

app.locals

该app.locals对象具有作为应用程序内局部变量的属性。

console.dir(app.locals.title)
// => 'My App'
console.dir(app.locals.email)
// => 'me@myapp.com'

一旦设置，app.locals属性值将在应用程序的整个生命周期中保持不变，而res.locals属性仅在请求的生命周期内有效。
您可以在应用程序内呈现的模板中访问局部变量。这对于为模板以及应用程序级数据提供帮助功能很有用。可以在中间件中通过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属性包含一个或多个安装了子应用程序的路径模式。

子应用程序是该应用程序的一个实例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

它与对象的baseUrl属性类似req，不同之处在于它req.baseUrl 返回匹配的URL路径，而不是匹配的模式。
如果子应用程序安装在多个路径模式上，则app.mountpath返回其安装模式的列表，如以下示例所示。

var admin = express()
admin.get('/', function (req, res) {
  console.dir(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.on（’mount’，callback（parent））

当mount事件安装在父应用程序上时，该事件将在子应用程序上触发。父应用程序将传递给回调函数。
注意
子应用程序将：

• 不继承具有默认值的设置的值。您必须在子应用程序中设置值。
• 继承设置的值，没有默认值。

有关详细信息，请参阅“ 应用程序设置”。

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)

方法

app.all（path，callback [，callback …]）

此方法类似于标准的app.METHOD（）方法，但它匹配所有HTTP动词。
参数

您可以提供行为类似于中间件的多个回调函数，除了这些回调可以调用next('route')以绕过其余的路由回调。您可以使用此机制在路由上施加先决条件，然后在没有理由继续使用当前路由的情况下将控制权传递给后续路由。
由于路由器和应用程序实现了中间件接口，因此您可以像使用任何其他中间件功能一样使用它们。
有关示例，请参见Middleware回调函数示例。 | None |

示例

对于/secret使用GET，POST，PUT，DELETE或任何其他HTTP请求方法的请求，将执行以下回调：

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

该app.all()方法对于将“全局”逻辑映射为特定路径前缀或任意匹配很有用。例如，如果将以下内容放在所有其他路由定义的顶部，则要求从该点开始的所有路由都需要身份验证，并自动加载用户。请记住，这些回调不必充当端点：loadUser 可以执行任务，然后调用next()以继续匹配后续路由。

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

或等效的：

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

另一个示例是列入白名单的“全局”功能。该示例与上面的示例相似，但是仅限制了以“ / api”开头的路径：

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

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

使用指定的回调函数将HTTP DELETE请求路由到指定的路径。有关更多信息，请参阅路由指南。

争论

您可以提供行为类似于中间件的多个回调函数，除了这些回调可以调用next('route')以绕过其余的路由回调。您可以使用此机制在路由上施加先决条件，然后在没有理由继续使用当前路由的情况下将控制权传递给后续路由。
由于路由器和应用程序实现了中间件接口，因此您可以像使用任何其他中间件功能一样使用它们。
有关示例，请参见Middleware回调函数示例。 | None |

示例

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

app.disable(name)

将布尔设置设置name为false，其中name是应用程序设置表中的属性之一。调用app.set('foo', false)Boolean属性与调用相同app.disable('foo')。
例如：

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

app.disabled(name)

返回true是否name禁用了布尔设置（false），其中name是应用设置表中的属性之一。

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

app.enable(name)

将布尔设置设置name为true，其中name是应用程序设置表中的属性之一。调用app.set('foo', true)Boolean属性与调用相同app.enable('foo')。

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

app.enabled(name)

返回true设置name是否已启用（true），其中name是应用程序设置表中的属性之一。

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

app.engine(ext, callback)

将给定的模板引擎注册callback为ext。
默认情况下，Express将require()基于文件扩展名启动引擎。例如，如果您尝试呈现“ foo.pug”文件，则Express会在内部调用以下内容，并缓存require()后续调用以提高性能。

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

对于不提供.__express现成的引擎，或者如果您希望将另一个扩展“映射”到模板引擎，请使用此方法。
例如，要将EJS模板引擎映射到“ .html”文件：

app.engine('html', require('ejs').renderFile)

在这种情况下，EJS提供了.renderFile()一种与Express期望的签名相同的方法：(path, options, callback)，但请注意，该方法在ejs.__express内部将此别名作为别名，因此，如果您使用“ .ejs”扩展名，则无需执行任何操作。
某些模板引擎不遵循此约定。该 consolidate.js库映射节点模板引擎要遵守这个习惯，所以他们与快递无缝协作。

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

app.get(name)

返回name应用程序设置的值，其中name是应用程序设置表中的字符串之一 。例如：

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

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

使用指定的回调函数将HTTP GET请求路由到指定的路径。

参数

您可以提供行为类似于中间件的多个回调函数，除了这些回调可以调用next('route')以绕过其余的路由回调。您可以使用此机制在路由上施加先决条件，然后在没有理由继续使用当前路由的情况下将控制权传递给后续路由。
由于路由器和应用程序实现了中间件接口，因此您可以像使用任何其他中间件功能一样使用它们。
有关示例，请参见Middleware回调函数示例。 | None |

有关更多信息，请参阅路由指南。

示例

app.get('/', function (req, res) {
  res.send('GET request to homepage')
})

app.listen(path, [callback])

启动UNIX套接字，并侦听给定路径上的连接。此方法与Node的http.Server.listen（）相同。

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

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

绑定并侦听指定主机和端口上的连接。此方法与Node的http.Server.listen（）相同。
如果端口被省略或为0，则操作系统将分配任意一个未使用的端口，这对于诸如自动化任务（测试等）的情况很有用。

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

实际上，app返回的express()是JavaScript Function，旨在作为回调传递到Node的HTTP服务器以处理请求。这使为应用程序的HTTP和HTTPS版本提供相同的代码库变得容易，因为该应用程序不继承自这些代码（只是一个回调）：

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

注意： 实际上，实际上支持Node的http.Server.listen（）方法的所有形式 。

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

路由一个HTTP请求，其中METHOD是请求的HTTP方法，例如小写的GET，PUT，POST等。因此，实际的方法是app.get()， app.post()，app.put()，等等。有关完整列表，请参见下面的路由方法。

参数

您可以提供行为类似于中间件的多个回调函数，除了这些回调可以调用next('route')以绕过其余的路由回调。您可以使用此机制在路由上施加先决条件，然后在没有理由继续使用当前路由的情况下将控制权传递给后续路由。
由于路由器和应用程序实现了中间件接口，因此您可以像使用任何其他中间件功能一样使用它们。
有关示例，请参见Middleware回调函数示例。 | None |

路由方式

Express支持以下与相同名称的HTTP方法相对应的路由方法：

该API文档中有明确的项目只针对最流行的HTTP方法app.get()， app.post()，app.put()，和app.delete()。但是，上面列出的其他方法以完全相同的方式工作。
要路由转换为无效JavaScript变量名称的方法，请使用方括号表示法。例如，app['m-search']('/', function ...。

如果以前没有为app.get()HTTP HEAD方法调用该函数，则将自动为该方法调用该函数。GET``app.head()``app.get()

方法，app.all()不是从任何HTTP方法派生的，而是在所有 HTTP请求方法的指定路径上加载中间件。有关更多信息，请参见app.all。
有关路由的更多信息，请参见路由指南。

app.param([name], callback)

向路由参数添加回调触发器，其中参数name的名称或它们的数组，callback是回调函数。回调函数的参数依次为请求对象，响应对象，下一个中间件，参数值和参数名称。
如果name是数组，callback则为触发器中声明的每个参数按声明顺序注册。此外，对于除最后一个参数以外的每个已声明参数，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'))
    }
  })
})

参数回调函数对于定义它们的路由器而言是本地的。它们不会被已安装的应用程序或路由器继承。因此，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

以下部分介绍app.param(callback)，从v4.11.0开始不推荐使用。

app.param(name, callback)通过仅将函数传递给，可以完全改变方法的行为app.param()。此函数是app.param(name, callback)行为方式的自定义实现-接受两个参数，并且必须返回中间件。
该函数的第一个参数是应捕获的URL参数的名称，第二个参数可以是可用于返回中间件实现的任何JavaScript对象。
函数返回的中间件决定了捕获URL参数时所发生的行为。
在此示例中，app.param(name, callback)签名被修改为app.param(name, accessId)。app.param()现在将接受名称和数字，而不是接受名称和回调。

var express = require('express')
var app = express()
// customizing the behavior of app.param()
app.param(function (param, option) {
  return function (req, res, next, val) {
    if (val === option) {
      next()
    } else {
      next('route')
    }
  }
})
// using the customized app.param()
app.param('id', 1337)
// route to trigger the capture
app.get('/user/:id', function (req, res) {
  res.send('OK')
})
app.listen(3000, function () {
  console.log('Ready')
})

在此示例中，app.param(name, callback)签名保持不变，但是已定义了自定义数据类型检查功能来验证用户ID的数据类型，而不是中间件回调。

app.param(function (param, validator) {
  return function (req, res, next, val) {
    if (validator(val)) {
      next()
    } else {
      next('route')
    }
  }
})
app.param('id', function (candidate) {
  return !isNaN(parseFloat(candidate)) && isFinite(candidate)
})

‘ .‘字符不能用于在捕获正则表达式中捕获字符。例如，您不能使用'/user-.+/'来捕获'users-gami'，使用[\\s\\S]或[\\w\\W]代替（如'/user-[\\s\\S]+/'。 例子：

//captures '1-a_6' but not '543-azser-sder'
router.get('/[0-9]+-[[\\w]]*', function);
//captures '1-a_6' and '543-az(ser"-sder' but not '5-a s'
router.get('/[0-9]+-[[\\S]]*', function);
//captures all (equivalent to '.*')
router.get('[[\\s\\S]]*', function);

app.path()

返回应用程序的规范路径（字符串）。

var app = express()
var blog = express()
var blogAdmin = express()
app.use('/blog', blog)
blog.use('/admin', blogAdmin)
console.dir(app.path()) // ''
console.dir(blog.path()) // '/blog'
console.dir(blogAdmin.path()) // '/blog/admin'

在已安装应用程序的复杂情况下，此方法的行为会变得非常复杂：通常最好使用req.baseUrl来获取应用程序的规范路径。

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

使用指定的回调函数将HTTP POST请求路由到指定的路径。有关更多信息，请参阅路由指南。

参数

您可以提供行为类似于中间件的多个回调函数，除了这些回调可以调用next('route')以绕过其余的路由回调。您可以使用此机制在路由上施加先决条件，然后在没有理由继续使用当前路由的情况下将控制权传递给后续路由。
由于路由器和应用程序实现了中间件接口，因此您可以像使用任何其他中间件功能一样使用它们。
有关示例，请参见Middleware回调函数示例。 | None |

示例

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

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

使用指定的回调函数将HTTP PUT请求路由到指定的路径。

参数

您可以提供行为类似于中间件的多个回调函数，除了这些回调可以调用next('route')以绕过其余的路由回调。您可以使用此机制在路由上施加先决条件，然后在没有理由继续使用当前路由的情况下将控制权传递给后续路由。
由于路由器和应用程序实现了中间件接口，因此您可以像使用任何其他中间件功能一样使用它们。
有关示例，请参见Middleware回调函数示例。 | None |

例

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

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

通过callback函数返回视图的渲染HTML 。它接受一个可选参数，该参数是一个包含视图局部变量的对象。就像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)

返回单个路由的实例，然后您可以使用该路由通过可选的中间件来处理HTTP动词。使用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)

将设置分配name给value。您可以存储所需的任何值，但是可以使用某些名称来配置服务器的行为。这些特殊名称在应用程序设置表中列出。
调用app.set('foo', true)Boolean属性与调用相同 app.enable('foo')。同样，调用app.set('foo', false)Boolean属性与调用相同app.disable('foo')。
使用检索设置的值app.get()。

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

Application设置

下表列出了应用程序设置。
请注意，子应用程序将：

• 不继承具有默认值的设置的值。您必须在子应用程序中设置值。
• 继承设置的值，没有默认值；这些在下表中明确指出。

例外：子应用程序将继承的值，trust proxy即使它具有默认值（为了向后兼容）；子应用不会继承view cache生产中的价值（当NODE_ENV是“生产”时）。

trust proxy设置选项

有关更多信息，请 阅读使用代理。

通过以下任意一种方式设置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 | 信任来自前端代理服务器的_n _跃点作为客户端。 |
| 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 })

 |

<a name="etag.options.table"></a>
##### etag设置选项
**注意**：这些设置仅适用于动态文件，不适用于静态文件。该[express.static](http://expressjs.com/en/4x/api.html#express.static)中间件忽略这些设置。<br />ETag功能是使用[etag](https://www.npmjs.org/package/etag)包实现的 。有关更多信息，请参见其文档。

| 类型 | 值 |
| --- | --- |
| Boolean | `true`启用弱ETag。这是默认设置。<br />`false`完全禁用ETag。 |
| String | 如果为“ strong”，则启用强ETag。<br />如果为“弱”，则启用弱ETag。 |
| Function | 自定义ETag函数实现。仅当您知道自己在做什么时才使用此功能。

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

 |

<a name="app.use"></a>
### app.use([path,] callback [, callback...])
将指定的一个或多个[中间件](http://expressjs.com/guide/using-middleware.html)函数安装在指定的路径上：当所请求路径的基数匹配时，将执行中间件函数`path`。
<a name="hiwTJ"></a>
#### 参数
| 参数 | 描述 | 默认 |
| --- | --- | --- |
| `path` | 调用中间件功能的路径；可以是以下任何一个：<br />- 表示路径的字符串。<br />- 路径模式。<br />- 匹配路径的正则表达式模式。<br />- 以上任何组合的数组。<br />有关示例，请参见[路径示例](http://expressjs.com/en/4x/api.html#path-examples)。 | '/'（根路径） |
| `callback` | 回调函数；可：<br />- 中间件功能。<br />- 一系列中间件功能（以逗号分隔）。<br />- 一系列中间件功能。<br />- 以上所有的组合。<br />
您可以提供行为类似于中间件的多个回调函数，除了这些回调可以调用`next('route')`以绕过其余的路由回调。您可以使用此机制在路由上施加先决条件，然后在没有理由继续使用当前路由的情况下将控制权传递给后续路由。<br />由于[路由器](http://expressjs.com/en/4x/api.html#router)和[应用程序](http://expressjs.com/en/4x/api.html#application)实现了中间件接口，因此您可以像使用任何其他中间件功能一样使用它们。<br />有关示例，请参见[Middleware回调函数示例](http://expressjs.com/en/4x/api.html#middleware-callback-function-examples)。 | None |

<a name="description"></a>
#### 描述
一条路线将匹配紧随其后的任何路径，并带有“ `/`”。例如：`app.use('/apple', ...)`将匹配“ / apple”，“ / apple / images”，“ / apple / images / news”，等等。<br />由于`path`默认值为“ /”，因此将为对应用程序的每个请求执行不带路径安装的中间件。<br />例如，将针对对应用程序的_每个_请求执行以下中间件功能：
```javascript
app.use(function (req, res, next) {
  console.log('Time: %d', Date.now())
  next()
})

注意 子应用程序将：

• 不继承具有默认值的设置的值。您必须在子应用程序中设置值。
• 继承设置的值，没有默认值。

有关详细信息，请参阅“ 应用程序设置”。

中间件功能是顺序执行的，因此中间件包含的顺序很重要。

// this middleware will not allow the request to go beyond it
app.use(function (req, res, next) {
  res.send('Hello World')
})
// requests will never reach this route
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!')
})

路径示例

下表提供了一些path用于安装中间件的有效值的简单示例。

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

 |
| Path Pattern | 这将匹配以`/ 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(); });

这将匹配以/ ad和/ abcd开头的路径：

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

 |
| Regular Expression | 这将匹配以`/ abc`和`/ xyz`开头的路径：

app.use(/\/abc|\/xyz/, function (req, res, next) { next(); });

 |
| Array | 这将匹配以`/ abcd`，`/ xyza`，`/ lmn`和`/ pqr`开头的路径：

app.use([‘/abcd’, ‘/xyza’, /\/lmn|\/pqr/], function (req, res, next) { next(); });

 |

<a name="middleware-callback-function-examples"></a>
#### 中间件回调函数示例
下表提供了可被用作的中间件功能一些简单的例子`callback`参数`app.use()`，`app.METHOD()`和`app.all()`。尽管例子是`app.use()`，它们也适用于`app.use()`，`app.METHOD()`和`app.all()`。

| 用法 | 例 |
| --- | --- |
| 单一中间件 | 您可以在本地定义和安装中间件功能。

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

路由器是有效的中间件。

var router = express.Router(); router.get(‘/‘, function (req, res, next) { next(); }); app.use(router);

Express应用程序是有效的中间件。

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应用程序中使用[express.static](http://expressjs.com/guide/using-middleware.html#middleware.built-in)中间件的一些示例。<br />从应用程序目录中的“公共”目录为应用程序提供静态内容：
```javascript
// GET /style.css etc
app.use(express.static(path.join(__dirname, 'public')))

仅在中间件的请求路径带有“ / static”前缀时，才将中间件安装在“ / static”处以提供静态内容：

// GET /static/style.css etc.
app.use('/static', express.static(path.join(__dirname, 'public')))

通过在静态中间件之后加载记录器中间件来禁用静态内容请求的日志记录：

app.use(express.static(path.join(__dirname, 'public')))
app.use(logger())

提供来自多个目录的静态文件，但将“ ./public”优先于其他目录：

app.use(express.static(path.join(__dirname, 'public')))
app.use(express.static(path.join(__dirname, 'files')))
app.use(express.static(path.join(__dirname, 'uploads')))