Express 4.x API---(1)_app.disable('x-powered-by')-优快云博客

本文档详细介绍了Express.js框架的API使用方法，包括创建应用、配置中间件、路由请求等核心功能，并提供了丰富的示例代码帮助开发者快速上手。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

最近在看express，可是在工作中根本用不到，那我就来翻译他们的文档，学习其文档，目前来说再好不过，同时也是为大家学习express提供一点方便。
原文路径:http://expressjs.com/4x/api.html。

这个只是部分，还有就是我不是web出生，有些专业词汇翻译很烂，还有就是我的英语也比较烂。
项目地址:https://git.oschina.net/zhouX/express-4.x-api-Chinese.git

你也可以通过这里访问（在csdn上的Markdown显示不太友好）:https://www.zybuluo.com/XiangZhou/note/208532

express()

express()用来创建一个Express的程序。express()方法是express模块导出的顶层方法。

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

Methods

express.static(root, [options])

express.static是Express中唯一的内建中间件。它以server-static模块为基础开发，负责托管 Express 应用内的静态资源。
参数root为静态资源的所在的根目录。
参数options是可选的，支持以下的属性：

属性	描述	类型	默认值
dotfiles	是否响应点文件。供选择的值有”allow”，”deny”和”ignore”	String	“ignore”
etag	使能或者关闭etag	Boolean	true
extensions	设置文件延期回退	Boolean	true
index	发送目录索引文件。设置false将不发送。	Mixed	“index.html”
lastModified	设置文件在系统中的最后修改时间到`Last-Modified`头部。可能的取值有`false`和`true`。	Boolean	true
maxAge	在Cache-Control头部中设置`max-age`属性，精度为毫秒(ms)或则一段ms format的字符串	Number	0
redirect	当请求的pathname是一个目录的时候，重定向到尾随”/”	Boolean	true
setHeaders	当响应静态文件请求时设置headers的方法	Funtion

如果你想获得更多关于使用中间件的细节，你可以查阅Serving static files in Express。

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。

它还有一些属性设置，这些属性可以改变程序的行为。获得更多的信息，可以查阅Application settings。

Properties

app.locals

app.locals对象是一个javascript对象，它的属性就是程序本地的变量。

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

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

一旦设定，app.locals的各属性值将贯穿程序的整个生命周期，与其相反的是res.locals，它只在这次请求的生命周期中有效。

在程序中，你可以在渲染模板时使用这些本地变量。它们是非常有用的，可以为模板提供一些有用的方法，以及app级别的数据。通过req.app.locals(具体查看req.app)Locals可以在中间件中使用。

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

它和req对象的baseUrl属性比较相似，除了req.baseUrl是匹配的URL路径，而不是匹配的模式。如果一个子程序被挂载在多条路径模式，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);
    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

Events

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

Methods

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

app.all方法和标准的app.METHOD()方法相似，除了它匹配所有的HTTP动词。
对于给一个特殊后缀映射一个全局的逻辑处理，或者无条件匹配，它是很有效的。例如，如果你把下面内容放在所有其他的路由定义的前面，它要求所有从这个点开始的路由需要认证和自动加载一个用户。记住这些回调并不是一定是终点:loadUser可以在完成了一个任务后，调用next()方法来继续匹配随后的路由。

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

或者这种相等的形式:

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

另一个例子是全局的白名单方法。这个例子和前面的很像，然而它只是限制以/api开头的路径。

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

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

路由HTTP DELETE请求到有特殊回调方法的特殊的路径。获取更多的信息，可以查阅routing guide。
你可以提供多个回调函数，它们的行为和中间件一样，除了这些回调可以通过调用next('router')来绕过剩余的路由回调。你可以使用这个机制来为一个路由设置一些前提条件，如果不能满足当前路由的处理条件，那么你可以传递控制到随后的路由。

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

app.disable(name)

设置类型为布尔的设置名为name的值为false，此处的name是app settings table中各属性的一个。调用app.set('foo', false)和调用app.disable('foo')是等价的。
比如:

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

app.disabled(name)

返回true如果布尔类型的设置值name被禁用为false，此处的name是app settings table中各属性的一个。

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

app.enable(name)

设置布尔类型的设置值name为true，此处的name是app settings table中各属性的一个。调用app.set('foo', true)和调用app.enable('foo')是等价的。

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

app.enabled(name)

返回true如果布尔类型的设置值name被启动为true，此处的name是app settings table中各属性的一个。

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

app.engine(ext, callback)

注册给定引擎的回调，用来渲染处理ext文件。
默认情况下，Express需要使用require()来加载基于文件扩展的引擎。例如，如果你尝试渲染一个foo.jade文件，Express在内部调用下面的内容，同时缓存require()结果供随后的调用，来加速性能。

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

使用下面的方法对于那些没有提供开箱即用的.__express方法的模板，或者你希望使用不同的模板引擎扩展。
比如，使用EJS模板引擎来渲染.html文件：

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

在这个例子中，EJS提供了一个.renderFile方法，这个方法满足了Express规定的签名规则：(path, options, callback)，然而记住在内部它只是ejs.__express的一个别名，所以你可以在不做任何事的情况下直接使用.ejs扩展。
一些模板引擎没有遵循这种规范，consolidate.js库映射模板引擎以下面的使用方式，所以他们可以无缝的和Express工作。

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

app.get(name)

获得设置名为name的app设置的值，此处的name是app settings table中各属性的一个。
如下：

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

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

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

路由HTTP GET请求到有特殊回调的特殊路径。获取更多的信息，可以查阅routing guide。
你可以提供多个回调函数，它们的行为和中间件一样，除了这些回调可以通过调用next('router')来绕过剩余的路由回调。你可以使用这个机制来为一个路由设置一些前提条件，如果请求没能满足当前路由的处理条件，那么传递控制到随后的路由。

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

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

绑定程序监听端口到指定的主机和端口号。这个方法和Node中的http.Server.listen()是一样的。

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

通过调用express()返回得到的app实际上是一个JavaScript的Function，被设计用来作为一个回调传递给Node HTTP servers来处理请求。这样，其就可以很简便的基于同一份代码提供http和https版本，所以app没有从这些继承(它只是一个简单的回调)。

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

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

app.listen()方法是下面所示的一个便利的方法(只针对HTTP协议):

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

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

路由一个HTTP请求，METHOD是这个请求的HTTP方法，比如GET，PUT，POST等等，注意是小写的。所以，实际的方法是app.get()，app.post()，app.put()等等。下面有关于方法的完整的表。
获取更多信息，请看routing guide。
Express支持下面的路由方法，对应与同名的HTTP方法：

checkout
connect
copy
delete
get
head
lock
merge
mkactivity

mkcol
move
m-search
notify
options
patch
post
propfind
proppatch

purege
put
report
search
subscribe
trace
unlock
unsubscribe

如果使用上述方法时，导致了无效的javascript的变量名，可以使用中括号符号，比如,app['m-search']('/', function ...

你可以提供多个回调函数，它们的行为和中间件一样，除了这些回调可以通过调用next('router')来绕过剩余的路由回调。你可以使用这个机制来为一个路由设置一些前提条件，如果请求没有满足当前路由的处理条件，那么传递控制到随后的路由。

本API文档把使用比较多的HTTP方法app.get()，app.post，app.put()，app.delete()作为一个个单独的项进行>>说明。然而，其他上述列出的方法以完全相同的方式工作。

app.all()是一个特殊的路由方法，它不属于HTTP协议中的规定的方法。它为一个路径加载中间件，其对所有的请求方法都有效。

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

app.param([name], callback)

给路由参数添加回调触发器，这里的name是参数名或者参数数组，function是回调方法。回调方法的参数按序是请求对象，响应对象，下个中间件，参数值和参数名。
如果name是数组，会按照各个参数在数组中被声明的循序将回调触发器注册下来。还有，对于除了最后一个参数的其他参数，在他们的回调中调用next()来调用下个声明参数的回调。对于最后一个参数，在回调中调用next()将调用位于当前处理路由中的下一个中间件，如果name只是一个string那就和它是一样的(就是说只有一个参数，那么就是最后一个参数，和数组中最后一个参数是一样的)。
例如，当:user出现在路由路径中，你可以映射用户加载的逻辑处理来自动提供req.user给这个路由，或者对输入的参数进行验证。

    app.param('user', function(req, res, next, id) {
        User.find(id, function(error, user) {
            if (err) {
                next(err);
            }
            else if (user){
                req.user = user;
            } else {
                next(new Error('failed to load user'));
            }
        });
    });

对于Param的回调定义的路由来说，他们是局部的。它们不会被挂载的app或者路由继承。所以，定义在app上的Param回调只有是在app上的路由具有这个路由参数时才起作用。
在定义param的路由上，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 mathces 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, next) {
    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 mathes too

下面章节描述的app.param(callback)在v4.11.0之后被弃用。

通过只传递一个回调参数给app.param(name, callback)方法，app.param(naem, callback)方法的行为将被完全改变。这个回调参数是关于app.param(name, callback)该具有怎样的行为的一个自定义方法，这个方法必须接受两个参数并且返回一个中间件。
这个回调的第一个参数就是需要捕获的url的参数名，第二个参数可以是任一的JavaScript对象，其可能在实现返回一个中间件时被使用。
这个回调方法返回的中间件决定了当URL中包含这个参数时所采取的行为。
在下面的例子中，app.param(name, callback)参数签名被修改成了app.param(name, accessId)。替换接受一个参数名和回调，app.param()现在接受一个参数名和一个数字。

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

    app.param(function(param, option){
        return function(req, res, next, val) {
            if (val == option) {
                next();
            }
            else {
                res.sendStatus(403);
            }
        }
    });

    app.param('id', 1337);

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

    app.listen(3000, function() {
        console.log('Ready');
    });

在这个例子中，app.param(name. callback)参数签名保持和原来一样，但是替换成了一个中间件，定义了一个自定义的数据类型检测方法来检测user id的类型正确性。

    app.param(function(param, validator) {
        return function(req, res, next, val) {
            if (validator(val)) {
                next();
            }
            else {
                res.sendStatus(403);
            }
        }
    });

    app.param('id', function(candidate) {
        return !isNaN(parseFloat(candidate)) && isFinite(candidate);
    });

在使用正则表达式来，不要使用.。例如，你不能使用/user-.+/来捕获user-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()

通过这个方法可以得到app典型的路径，其是一个string。

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

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

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

如果app挂载很复杂下，那么这个方法的行为也会很复杂：一种更好用的方式是使用req.baseUrl来获得这个app的典型路径。

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

路由HTTP POST请求到有特殊回调的特殊路径。获取更多的信息，可以查阅routing guide。
你可以提供多个回调函数，它们的行为和中间件一样，除了这些回调可以通过调用next('router')来绕过剩余的路由回调。你可以使用这个机制来为一个路由设置一些前提条件，如果请求没能满足当前路由的处理条件，那么传递控制到随后的路由。

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

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

路由HTTP PUT请求到有特殊回调的特殊路径。获取更多的信息，可以查阅routing guide。
你可以提供多个回调函数，它们的行为和中间件一样，除了这些回调可以通过调用next('router')来绕过剩余的路由回调。你可以使用这个机制来为一个路由设置一些前提条件，如果请求没能满足当前路由的处理条件，那么传递控制到随后的路由。

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

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

通过callback回调返回一个view渲染之后得到的HTML文本。它可以接受一个可选的参数，可以参数包含了这个view需要用到的本地数据。这个方法类似与res.render(),除了它不能把渲染得到的HTML文本发送给客户端。

将app.render()当作是可以生成渲染视图字符串的工具方法。在res.render()内部，就是使用的app.render()来渲染视图。

如果使能了视图缓存，那么本地参数缓存就会保留。如果你想在开发的过程中缓存视图，设置它为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值，name是app settings table中属性的一项。
对于一个类型是布尔型的属性调用app.set('foo', ture)等价于调用app.enable('foo')。同样的，调用app.set('foo', false)等价于调用app.disable('foo')。
可以使用app.get()来取得设置的值：

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

Application Settings
如果name是程序设置之一，它将影响到程序的行为。下边列出了程序中的设置。

Property	Type	Value	Default
case sensitive routing	Boolean	启用区分大小写。	不启用。对`/Foo`和`/foo`处理是一样。
env	String	环境模型。	process.env.NODE_ENV(NODE_ENV环境变量)或者”development”
etag	Varied	设置`ETag`响应头。可取的值，可以查阅etag options table。更多关于HTTP ETag header。	weak
jsonp callback name	String	指定默认JSONP回调的名称。	?callback=
json replacer	String	JSON替代品回调	null
json spaces	Number	当设置了这个值后，发送缩进空格美化过的JSON字符串。	Disabled
query parser	Varied	设置值为`false`来禁用`query parser`，或者设置`simple`,`extended`，也可以自己实现`query string`解析函数。`simple`基于`Node`原生的`query`解析，querystring。	“extend”
strict routing	Boolean	启用严格的路由。	不启用。对`/foo`和`/foo/`的路由处理是一样。
subdomain offset	Number	用来删除访问子域的主机点分部分的个数	2
trust proxy	Varied	指示`app`在一个前向代理的后面，使用`x-Forwarded-`来确定连接和客户端的IP地址。注意:`X-Forwarded-`头部很容易被欺骗，所有检测客户端的IP地址是靠不住的。`trust proxy`默认不启用。当启用时，Express尝试通过前端代理或者一系列代理来获取已连接的客户端IP地址。`req.ips`属性包含了已连接客户端IP地址的一个数组。为了启动它，需要设置在下面trust proxy options table中定义的值。`trust proxy`的设置实现使用了`proxy-addr`包。如果想获得更多的信息，可以查阅它的文档	Disable
views	String or Array	`view`所在的目录或者目录数组。如果是一个数组，将按在数组中的顺序来查找`view`。	process.cwd() + ‘/views’
view cache	Boolean	启用视图模板编译缓存。	在生成环境默认开启。
view engine	String	省略时，默认的引擎被扩展使用。
x-powered-by	Boolean	启用`X-Powered-By:Express`HTTP头部	true

Options for trust proxy settings
查阅Express behind proxies来获取更多信息。

Type	Value
Boolean	如果为`true`，客户端的IP地址作为`X-Forwarded-*`头部的最左边的条目。如果为`false`，可以理解为`app`直接与英特网直连，客户端的IP地址衍生自`req.connection.remoteAddress`。`false`是默认设置。
IP addresses	一个IP地址，子网，或者一组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') // specify a single subnet app.set('trust proxy', 'loopback, 123.123.123.123') // specify a subnet and an address app.set('trust proxy', 'loopback, linklocal, uniquelocal') // specify multiple subnets as CSV app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array` 当指定IP地址之后, 这个IP地址或子网会被设置了这个IP地址或子网的`app`排除在外, 最靠近程序服务的没有委托的地址将被看做客户端IP地址。
Number	信任从前段代理到app中间小于等于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; })`

Options for etag settings
ETag功能的实现使用了etag包。如果你需要获得更多的信息，你可以查阅它的文档。

Type Value

Boolean

Type	Value
Boolean	设置为`true`，启用weak ETag。这个是默认设置。设置`false`，禁用所有的ETag。
String	如果是`strong`，使能strong ETag。如果是`weak`，启用`weak` ETag。
Function	客户自定义`ETag`方法的实现. 如果你使用这个，请确保你自己知道你在干什么。 `app.set('etag', function (body, encoding) { return generateHash(body, encoding); // consider the function is defined })`

设置为`true`，启用weak ETag。这个是默认设置。设置`false`，禁用所有的ETag。

String 如果是`strong`，使能strong ETag。如果是`weak`，启用`weak` ETag。

Function

客户自定义`ETag`方法的实现. 如果你使用这个，请确保你自己知道你在干什么。

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

app.use([path,], function [, function…])

挂载中间件方法到路径上。如果路径未指定，那么默认为”/”。

一个路由将匹配任何路径如果这个路径以这个路由设置路径后紧跟着”/”。比如：app.use('/appale', >...)将匹配”/apple”，”/apple/images”，”/apple/images/news”等。

中间件中的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'
});

在一个路径上挂载一个中间件之后，每当请求的路径的前缀部分匹配了这个路由路径，那么这个中间件就会被执行。
由于默认的路径为/，中间件挂载没有指定路径，那么对于没有请求，这个中间件都会被处理。

    // this middleware will be executed for every request to the app.
    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');
    });

    // this middleware will never reach this route
    app.use('/', function(req, res) {
        res.send('Welcome');
    });

路径可以是代表路径的一串字符，一个路径模式，一个匹配路径的正则表达式，或者他们的一组集合。

下面是路径的简单的例子。

Type	Example
Path	`// will match paths starting with /abcd app.use('/abcd', function (req, res, next) { next(); })`
Path Pattern	`// will match paths starting with /abcd and /abd app.use('/abc?d', function (req, res, next) { next(); }) // will match paths starting with /abcd, /abbcd, /abbbbbcd and so on app.use('/ab+cd', function (req, res, next) { next(); }) // will match paths starting with /abcd, /abxcd, /abFOOcd, /abbArcd and so on app.use('/ab\*cd', function (req, res, next) { next(); }) // will match paths starting with /ad and /abcd app.use('/a(bc)?d', function (req, res, next) { next(); })`
Regular Expression	`// will match paths starting with /abc and /xyz app.use(/\/abc\|\/xyz/, function (req, res, next) { next(); })`
Array	`// will match paths starting with /abcd, /xyza, /lmn, and /pqr app.use(['/abcd', '/xyza', /\/lmn\|\/pqr/], function (req, res, next) { next(); })`

方法可以是一个中间件方法，一系列中间件方法，一组中间件方法或者他们的集合。由于router和app实现了中间件接口，你可以使用它们作为你想的任何中间件方法。

Usage	Example
单个中间件	你可以局部定义和挂载一个中间件。 `app.use(function (req, res, next) { next(); })` 一个`router`是有效的中间件。 `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中间件。
为程序托管位于程序目录下的public目录下的静态资源：

// GET /style.css etc
app.use(express.static(__dirname + '/public'));

在/static目录下挂载中间件来提供静态资源委托服务当请求是以/static为前缀的时候。

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

通过在设置静态资源中间件之后加载日志中间件来关闭静态资源请求的日志。

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