原始链接：https://segmentfault.com/a/1190000010190604#articleHeader22

1.Express简介

Express是基于Node.js平台、快速、开放、极简的web开发框架，它提供了一系列强大的特性，帮助你创建各种web和移动设备应用。
Express不对Node.js已有特性进行二次抽象，我们只是在它之上扩展了web应用所需的基本功能。
注意：Express是一个自身功能极简，完全是由路由和中间件构成的一个web开发框架：从本质上来说，一个Express应用就是在调用各种中间件。
API方面：丰富的HTTP快捷方法和任意排列组合的Connect中间件，让你创建健壮、友好的API变得既快速又简单。
特性：

• Robust routing
• Focus on high performance
• Super-high test coverage
• HTTP helpers(redirection, caching, etc)
• View system supporting 14+ template engines
• Content negotiation
• Executable for generating applications quickly

安装和hello world

--save：安装模块时，如果制定了--save参数，那么此模块将被添加到package.json文件中的dependencies依赖列表中，然后通过npm install命令即可自动安装依赖列表中所列出的所有模块。如果只是临时安装，不想把它添加到依赖列表中，只要省略--save参数就可以。
tips：项目文件夹的名字和所要安装的项目依赖不能重名。（例如创建了一个名为express的项目文件及，如果初始化后，安装express。会报错：Refusing to install express as a dependency of itself。）

# 工作目录
$ mkdir myapp
$ cd myapp

# 通过npm init命令为你的应用创建一个package.json文件
$ npm init 

# 应用的入口文件
entry point: app.js

# 安装Express并将其保存在依赖列表中
$ npm install express --save

下面的代码启动一个服务并监听从3000端口进入的所有连接请求。他将对所有(/)URL或路由返回hello world字符串。对于其他所有路径返回404 Not Found。
req(request，请求)和res(response, 响应)与Node提供的对象完全一致，因此，你可以调用req.pipe()，req.on('data', callback)以及任何Node提供的方法。

const express = require('express');
let app = express();

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

let server = app.listen(3000, function() {
  let host = server.address().address;
  let port = server.address().port;

  console.log(`app listening at port: ${port}`);
});

# 启动此应用
$ node app.js

http://localhost:3000/

Express应用生成器

通过应用生成器，express可以快速创建一个应用的骨架。
通过Express应用生成器创建应用只是众多方法中的一种，你可以根据自己的需求修改它。

# 安装
$ npm install express-generator -g

# 列出所有可用命令
$ express -h

# 初始化一个express项目
$ express myapp
$ cd myapp

# 然后安装所有依赖包
$ npm install

# 启动此应用
$ npm start

http://localhost:3000/

2.路由（Routing）

路由是指如何定义应用的端点(URIs)以及如何响应客户端的请求。
路由（Routing）是由URI（路径）和一个特定的HTTP方法（get、post、put、delete等）组成的，涉及到应用如何响应客户端对某个网站节点的访问。

结构

路由的定义由以下结构组成：

• app是一个express实例
• method是某个HTTP请求方式中的一个，Express定义了如下和HTTP请求对应的路由方法：get, post, put, head, delete, options, tracem copy, lock, mkcol, move, purge, propfind, proppatch, unlock, report, mkactivity, checkout, merge, m-search, notify, subscirbe, unsubscirbe, patch, search, connect。有一些路由方法名并不是符合规范的javaScript变量名，此时用括号记法，比如：app['m-search'('/', function ...)
• path是服务端的路径
• handler每一个路由都可以有一个或者多个处理器函数，当匹配到路由时，这些函数将被执行。

app.method(path, [handler...], handler)

// respond with"hello world" when a GET request is made to the homepage
app.get('/', function(req, res) {
  res.send('hello World!');
});

app.all()是一个特殊的路由方法，没有任何HTTP方法与其对应，它的作用是对于一个路径上所有请求加载中间件。在下面的例子中，来自/secret的请求，不管使用GET、POST或者其他任何HTTP请求，句柄都会得到执行。

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

路由路径path

路由路径和请求方法一起定义了请求的端点，它可以是字符串，字符串模式或者正则表达式。
使用字符串的路由路径示例：

// 匹配根路径的请求
app.get('/', function(req, res) {
  res.send('root');
});

// 匹配/about路径的请求
app.get('/about', function(req, res) {
  res.send('about');
});

// 匹配/random.text路径的请求 
app.get('/random.text', function(req, res) {
  res.send('random.text');
});

使用字符串模式的路由路径示例：

// 匹配 acd 和 abcd
app.get('/ab?cd', function(req, res) {
  res.send('ab?cd');
});

// 匹配 /abe 和 /abcde
app.get('/ab(cd)?e', function(req, res) {
 res.send('ab(cd)?e');
});

// 匹配 abcd、abbcd、abbbcd等
app.get('/ab+cd', function(req, res) {
  res.send('ab+cd');
});

// 匹配 abcd、abxcd、abRABDOMcd、ab123cd等
app.get('/ab*cd', function(req, res) {
  res.send('ab*cd');
});

使用正则表达式的路由路径示例：

// 匹配任何路径中含有a的路径：
app.get(/a/, function(req, res) {
  res.send('/a/');
});

// 匹配butterfly、dragonfly，不匹配bufferflyman、dragonfly man等
app.get(/.*fly$/, function(req, res) {
  res.send('/.*fly$/');
});

路由句柄handler

注意：Can't set headlers after they are sent
可以为请求提供多个回调函数，其行为类似于中间件。唯一的区别是这些回调函数有可能调用next('route')方法而略过其他路由回调函数，可以利用该机制为路由定义前提条件，如果在现有路径上继续执行没有意义，则可以将控制权交给剩下的路径、
路由句柄有多种形式，可以是一个函数，一个函数数组，或者两者混合，如下所示：
使用一个回调函数处理路由：

app.get('/example/a', function(req, res) {
  res.send('Hello from A!');
});

使用多个回调函数处理路由（记得指定该next对象）：

app.get('/example/b', function(req, res, next) {
  console.log('response will be sent by the next function ...');
  next();
}, function(req, res) {
  res.send('Hello from B!');
});

使用回调函数数组处理路由：

var cb0 = function(req, res, next) {
  console.log('CB0');
  next();
}

var cb1 = function(req, res, next) {
  console.log('CB1');
  next();
}

var cb2 = function(req, res) {
  res.send('Hello from C!');
}

app.get('example/c', [cb0, cb1, cb2]);

混合函数和函数数组处理路由：

var cb0 = function(req, res, next) {
  console.log('CB0');
  next();
}

var cb1 = function(req, res, next) {
  console.log('CB1');
  next();
}

app.get('/example/d', [cb0, cb1], function(req, res, next) {
  console.log('reponse will be sent by the next function...');
  next();
}, function() {
  res.send('Hello from D!');
});

响应方法 res

下表响应对象（res）的方法向客户端返回响应，终结请求相应的循环。如果在路由句柄中一个方法也不调用，来自客户端的请求会一直挂起。
res.down() 提示下载文件
res.end() 终结响应处理流程
res.json() 发送一个JSON格式的响应
res.jsonp() 发送一个支持JSONP的JSON格式响应
res.redirect() 重定向请求
res.render() 渲染视图模板
res.send() 发送各种类型的响应
res.sendFile() 以八位字节流的形式发送文件
res.sentStatus() 设置响应状态代码，并将其以字符串形式作为响应体的一部分发送。

app.route()

可使用app.route()创建路由路径的链式路由句柄。由于路径在一个地方制定，这样做有助于创建模块化的路由，且减少了代码冗余和拼写错误。

app.route('/book')
  .get(function(req, res) {
    res.send('Get a random book');
  })
  .post(function(req, res) {
    res.send('Add a book');
  })
  .put(function(req, res) {
    res.send('Update the book');
  });

express.Router

可使用express.Router类创建模块化，可挂载的路由句柄。
下面的实例程序创建了一个路由模块，并加载了一个中间件，定义了一些路由，并且将它们挂载在至应用的路径上，在app目录下创建名为bird.js的文件，内容如下：

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

//  该路由使用的中间件
router.use(function timeLog(req, res, next) {
  console.log('Time: ', Date.now());
  next();
});
//  定义网站主页的路由
router.get('/', function(req, res) {
  res.send('Birds home page');
});
//  定义about页面的路由
router.get('/about', function(req, res) {
  res.send('About Birds');
});

module.exports = router;

然后在应用中加载路由模块，应用即可处理发自/birds和birds/about的请求，并且调用为路由制定的timeLog中间件。

var birds = require('./birds');
...
app.use('/birds', birds);

3.中间件（Middleware）

Express是一个子很功能极简，完全是路由和中间件构成的一个web开发框架：从本质上来说，一个Express应用就是在调用各种中间件。
中间件（Middleware）是一个函数，它可以访问请求对象（req），响应对象（res），和web应用中处于请求-响应循环流程中的中间件，一般命名为next的变量。
中间件的功能包括：

• 执行任何代码。
• 修改请求和响应对象。
• 终结请求-响应循环。
• 调用堆栈中的下一个中间件。
  注意：如果当前中间件没有终结请求-响应循环，则必须调用next()方法将控制器交给下一个中间件，否则请求就会挂起。

app.use

app.use([path], function)

Use the given middleware function, with optional mount path, defaulting to "/".
一个中间件处理器，请求来了，让那些中间件先处理一遍

• 没有挂载路径的中间件，应用的每个请求都会执行该中间件。
• 挂在至/path的中间件，任何指向/path的请求都会执行它。

中间件分类

Express应用可使用如下几种中间件：

• 应用级中间件
• 路由级中间件
• 错误处理中间件
• 内置中间件
• 第三方中间件

1.应用级中间件

应用级中间件绑定到app对象使用app.use()和app.METHOD()，其中：METHOD是需要处理的HTTP请求的方法，例如：GET，PUT，POST等等，全部小写。例如：

var app = express();

//  没有挂载路径的中间件，应用的每个请求都会执行该中间件
app.use(function(req, res, next) {
  console.log('Time: ', Date.now());
  next();
});

//  挂载至/user/:id的中间件，任何指向/user/:id的请求都会执行它
app.use('/user/:id', function(req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

//  路由和句柄函数（中间件系统），处理指向/user/:id的GET请求
app.get('/user/:id'. function(req, res, next) {
  res.send('USER');
});

// 一个中间件栈，对任何指向/user/:id的HTTP请求打印出相关信息
app.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originalUrl);
  next();
}, function(req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

2.路由级中间件

路由级中间件和应用级中间件一样，只是它绑定的对象为express.Router()。路由级使用router.use()或router.VERB()加载。
上述应用级中间件系统，可以通过如下代码写为路由级：

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

//  没有挂载路径的中间件，通过该路由的每个请求都会执行该中间件
router.use(function(req, res, next) {
  console.log('Time:', Date.now());
  next();
});

//  一个中间件栈，显示任何指向/user/:id的HTTP请求信息
router.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originUrl);
  next();
}, function(req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

//  一个中间件栈，处理指向/user/:id的GET请求
router.get('/user/:id', function(req, res, next) {
  //  如果user id为0，跳到下一个路由
  if(req.params.id == 0)  next('route');
  //  负责将控制权交给栈中下一个中间件
  else next();
}, function(req, res, next) {
  //  渲染常规页面
  res.render('regular');
});

//  处理/user/:id，渲染一个特殊页面
router.get('/user/:id', function(req, res, next) {
  console.log(req.params.id);
  res.render('special');
});

//  将路由挂载至应用
app.use('/', router);

3.错误处理中间件

错误处理中间件与其他中间件定义类似，只是必须使用4个参数(err, req, res, next)，即时不需要next对象，也必须在签名中声明它，否则中间件将会被识别为一个常规中间件，不能处理错误。
错误处理中间件应当在其他app.use()和路由调用之后才能加载，比如：

var bodyParser = require('body-Parser');
var methodOverride = require('method-override');

app.use(bodyParser());
app.use(methodOverride());
app.use(function(err, req, res, next) {
  //  业务逻辑
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

中间件返回的响应是随意的，可以响应一个HTML错误页面，依据简单的话，一个JSON字符串，或者其他任何您想要的东西。
为了便于组织（更高级的框架），您可能会像定义常规中间件一样，定义多个错误处理中间件，比如您想为使用XHR的请求定义一个，还想为没有使用的定义一个，那么：

var bodyParser = require('body-parser');
var methodOverride = require('method-override');

app.use(bodyParser());
app.use(methodOverride());
app.use(logErrors);
app.use(clientErrorHandler); 
app.use(errorHandler);

// logErrors将请求和错误信息写入标准错误输出、日志或类似服务：
function logErrors(err, req, res, next) {
  console.log(err.stack);
  next(err);
}

//  clientErrorHandler的定义如下（注意这里将错误直接传给了next）
function clientErrorHandler(err, req, res, next) {
  if(req.xhr) {
    res.status(500).send({ error: 'Something blew up!'});
  } else {
    next(err);
  }
}

//  errorHandler能捕获所有错误，其定义如下：
function errorHandler(err, req, res, next) {
  res.status(500);
  res.render('error', {error: err});
}

4.内置中间件

Express以前内置的中间件现在已经全部单独作为模块安装使用了。
express.static是Express唯一内置的中间件，它基于serve-static，负责在Express应用中提供托管静态资源的服务。

5.第三方中间件

下面的例子安装并加载了一个解析cookie的中间件：cookie-parser

$ npm install cookie-parser

var express = require('express');
var app = express();
var cookieParser = require('cookie-parser');

//  加载用于解析cookie的中间件
app.use(cookieParser());

4.托管静态文件

通过Express内置的express.static可以方便的托管静态文件，例如：图片、CSS、JavaScript文件等。将静态资源文件所在的目录作为参数传递给express.static，中间件就可以提供静态资源文件的访问了。

使用

所有文件的路径都是相对于存放目录的，因此，存放静态文件的目录名不会出现在URL中。
假设在public目录放置了图片、CSS和JavaScript文件，你就可以：

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

现在，public目录下的文件就可以访问了。

• http://localhost:3000/images/...
• http://localhost:3000/css/style.css
• http://localhost:3000/js/app.js
• http://localhost:3000/hello.html
  如果你的静态资源放在多个目录下面，你可以多次调用express.static中间件。
  访问静态资源文件时，express,static中间件会根据目录添加的顺序查找所需的文件。

app.use(express.static('public'));
app.use(express.static('files'));

如果你希望通过express.static访问的文件都存放在一个虚拟目录中（即目录根本不存在），可以通过为静态资源目录指定一个挂载路径的方式来实现，如下所示：

app.use('/static', express.static('public'));

现在，你就可以通过带有/static前缀的地址来访问public目录下面的文件了。

• http://localhost:3000/static/images/kitten.jpg
• http://localhost:3000/static/css/style.css
• http://localhost:3000/static/js/app.js
• http://localhost:3000/static/images/bg.png
• http://localhost:3000/static/hello.html

path.join()

注意：Arguments to the path join must be strings
将多个参数组合成一个path，语法：

path.join([path1], [path2], [...]);

由于该方法属于path模块，使用前需要引入path模块

const express = require('express');
const path = require('path');

var app = express();

app.set('views', path.join(__dirname, 'views'));

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

5.Express中使用模板引擎

安装相应的模板引擎npm软件包，不需要在页面require('pug');

$ npm install pug --save

编写模板文件

html
  head
    title != title
  body
    h1 != message

然后创建一个路由，来渲染模板文件，模板文件会被渲染为HTML。如果没有设置view enginine，您需要指明视图文件的后缀，否则就会遗漏它。

• views 存放模板文件的目录
• view.engine 注册模板引擎

const express = require('express');

let app = express();

// view engine setup
app,set('views', ['./v']);
app,set('view engine', 'pug');

//  http://localhost:3000/index
app.get('/index', function(req, res) {
  res.render('index', {
    title: 'Hey',
    message: 'view engine, Hello there!'
  });
});

//  首页路由
app.get('/', function(req, res) {
  res.send('index routing, hello world');
});

let server = app.listen(3000, function() {
  let host = server.address().address;
  let port = server.address().port;

  console.log(`app listening at port: ${port}`);
});

6.Express 4迁移

Express 4是对Express 3的一个颠覆性改变，也就是说如果您更新了Express，Express 3应用会无法工作。

1.对Express内核和中间件系统的改进

Express 4不再依赖Connect，而且从内核中移除了除express.static外的所有内置中间件。
也就是说现在的Express是一个独立的路由和中间件Web框架，Express的版本升级不再受中间件更新的影响。
移除了内置的中间件后，您必须显式地添加所有运行应用需要的中间件，请遵循如下步骤：
1.安装模块：
2.在应用中引入模块：
3.按照文档的描述使用模块：
下表列出了Express 3和Express 4对应的中间件：

2.路由系统

应用现在隐式加载路由中间件，因此不需要担心涉及到router中间件对路由中间件加载顺序的问题了。
定义路由的方式依然未变，但是新的路由系统有两个新功能帮助您组织路由：

• 添加了一个新类：express.Router，可以创建可挂载的模块化路由句柄。
  +添加了一个新方法：app.route()，可以为路由路径创建链式路由句柄。

3.其他变化

运行：

node .

迁移

卸载Express 3 应用生成器：

$ npm uninstall -g express

然后安装新的生成器：

$ npm install -g express-generator