一个Koa应用就是一个对象，包含了一个middleware数组，这个数组由一组Generator函数组成。这些函数负责对HTTP请求进行各种加工，比如生成缓存、指定代理、请求重定向等等
var koa = require('koa')
var app = koa()
app.use(function *(){
this.body = 'Hello World'
app.listen(3000)
上面的变量app就是一个Koa应用
Koa的中间件
koa 不在内核方法中绑定任何中间件，Koa的中间件必须是一个Generator函数
中间件通过当前应用的use方法注册
app.use(function* (next){
app.use方法的参数就是中间件，它是一个Generator函数，最大的特征就是function命令与参数之间，必须有一个星号。Generator函数的参数next，表示下一个中间件
推荐中间件
koa-router - RESTful resource router
koa-hbs - Express-style Handlebars view rendering
koa-static - static file serving middleware
Context(上下文)
Koa对象中的this表示上下文对象context，代表一次HTTP请求和回应，每次HTTP请求，就会创建一个新的context对象
context对象的很多方法，其实是定义在ctx.request对象或ctx.response对象上面，比如，ctx.type和ctx.length对应于ctx.response.type和ctx.response.length，ctx.path和ctx.method对应于ctx.request.path和ctx.request.method
this.request：指向Request对象
this.response：指向Response对象
this.req：指向Node的request对象
this.req：指向Node的response对象
this.app：指向App对象
Koa Request/Response 对象是对 node 的 request/response 进一步抽象和封装
官网文档：
中文文档：
(在这里可以找到推荐的中间件)
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：46391次
积分：2711
积分：2711
排名：第9527名
原创：164篇
评论：43条
(2)(11)(10)(1)(1)(7)(5)(10)(2)(4)(44)(43)(10)(1)(3)(1)(4)(4)(2)(1)(1)(4)Node.js框架之express与koa对比分析 - 推酷
Node.js框架之express与koa对比分析
提到Node.js开发，不得不提目前炙手可热的2大框架express和koa。Express诞生已有时日，是一个简洁而灵活的web开发框架，使用简单而功能强大。Koa相对更为年轻，是Express框架原班人马基于ES6新特性重新开发的敏捷开发框架，现在可谓风头正劲，大有赶超Express之势。
Express和koa都是服务端的开发框架，服务端开发的重点是对HTTP Request和HTTP Response两个对象的封装和处理，应用的生命周期维护以及视图的处理等。 以下将主要通过这些方面，对两者进行一个对比介绍，看看到底有什么区别。
Express主要基于Connect中间件框架，功能丰富，随取随用，并且框架自身封装了大量便利的功能，比如路由、视图处理等等。而koa主要基于co中间件框架，框架自身并没集成太多功能，大部分功能需要用户自行require中间件去解决，但是由于其基于ES6 generator特性的中间件机制，解决了长期诟病的“callback hell”和麻烦的错误处理的问题，大受开发者欢迎。
Express和koa初印象
先来一个Hello World，各自认识一下吧
var express = require('express')
var app = express()
//创建一个APP实例
//建一个项目根目录的get请求路由，回调方法中直接输出字符串Hello World!
app.get('/', function (req, res) {
res.send('Hello World!')
//监听端口，启动服务
app.listen(3000);
var koa = require('koa');
var route = require('koa-route');
//koa默认没有集成route功能，引入中间件
var app = koa();
//创建一个APP实例
//建一个项目根目录的get请求路由，回调方法中直接输出字符串Hello World!，就是挂载一个中间件
app.use(route.get('/', function *(){
this.body = 'Hello World';
//监听端口，启动服务
app.listen(3000);
可以看出来，两者创建一个基础的Web服务都非常简单，可以说几行代码就解决了问题。两者的写法也基本相同，最大的区别是路由处理Express是自身集成的，而koa需要引入中间件。以下是Koa官方文档对于两者特性的一个对比：
重要功能对比介绍
Middleware Kernel
Templating
Sending Files
通过后续的比较，大家其实可以看出，虽然koa看上去比express少集成了很多功能，但是使用起来其实基本一致，因为中间件非常丰富全面，需要什么require进来就行了（不一定要像express那样先帮你require好），使用起来反而更加灵活。
应用生命周期和上下文
我们在项目过程中，经常需要用到在整个应用生命周期中共享的配置和数据对象，比如服务URL、是否启用某个功能特性、接口配置、当前登录用户数据等等。属于比较基础的功能，两者都非常方便，koa的application context感觉使用起来更方便一点。
//共享配置，express提供了很多便利的方法
app.set('enableCache', true)
app.get('enableCache')//true
app.disable('cache')
app.disabled('cache')//true
app.enable('cache')
app.enabled('cache')//true
//应用共享数据：app.locals
app.locals.user = {name:&Samoay&, id:1234};
//配置，直接使用koa context即可
app.enableCache = true;
app.use(function *(next){
console.log(this.app.enableCache);
this.app.enableCache = false;
//just use this
this.staticPath = 'static';
//应用共享数据：ctx.state
this.state.user = {name:&Samoay&, id:1234};
请求 HTTP Request
服务器端需要进行什么处理，怎么处理以及处理的参数都依赖客户端发送的请求，两个框架都封装了HTTP Request对象，便于对这一部分进行处理。以下主要举例说明下对请求参数的处理，其它例如头信息、Cookie等请参考官方文档。两者除了写法上稍有区别，没太大区别。GET参数都可以直接通过Request对象获取，POST参数都需要引入中间件先parse，再取值。
// Express
// 获取QueryString参数
// GET /shoes?order=desc&shoe[color]=blue
req.query.order
// =& &desc&
req.query.shoe.color
// =& &blue&
// 通过路由获取Restful风格的URL参数
app.get('/user/:id?', function userIdHandler(req, res) {
console.log(req.params.id);
res.send('GET');
//获取POST数据:需要body-parser中间件
var bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({ extended: true }));
app.post('/', function (req, res) {
console.log(req.body);
res.json(req.body);
// 获取QueryString参数
// GET /?action=delete&id=1234
this.request.query
// =& { action: 'delete', id: '1234' }
// 通过路由获取Restful风格的URL参数
var route = require('koa-route');
app.use(route.get('/post/:id', function *(id){
console.log(id);
// =& 1234
// 获取POST数据:需要co-body中间件
// Content-Type: application/x-www-form-urlencoded
// title=Test&content=This+is+a+test+post
var parse = require('co-body');
app.use(route.post('/post/new', function *(){
var post = yield parse(this.request);//this
console.log(post);
// =& { title: 'Test', content: 'This is a test post' }
路由 Route
收到客户端的请求，服务需要通过识别请求的方法（HTTP Method: GET, POST, PUT...）和请求的具体路径(path)来进行不同的处理。这部分功能就是路由（Route）需要做的事情，说白了就是请求的分发，分发到不同的回调方法去处理。
// Express
// app.all表示对所有的路径和请求方式都要经过这些回调方法的处理，可以逗号方式传入多个
app.all('*', authentication, loadUser);
// 也可以多次调用
app.all('*', requireAuthentication)
app.all('*', loadUser);
// 也可以针对某具体路径下面的所有请求
app.all('/api/*', requireAuthentication);
// app.get GET方式的请求
app.get('/user/:id', function(req, res) {
res.send('user ' + req.params.id);
// app.post
POST方式的请求
app.post('/user/create', function(req, res) {
res.send('create new user');
这里需要说明2个问题，首先是
，在应用生命周期中也有一个
方法，用于获取项目配置。Express内部就是公用的一个方法，如果传入的只有1个参数就获取配置，2个参数就作为路由处理。其次是
app.use('*', cb)
app.all('*', cb)
的区别，前者是中间件方式，调用是有顺序的，不一定会执行到；后者是路由方式，肯定会执行到。
// 和Express不同，koa需要先引入route中间件
var route = require('koa-route');
//引入中间件之后支持的写法差不多，只是路径传入route，然后把route作为中间件挂载到app
app.use(route.get('/', list));
app.use(route.get('/post/new', add));
app.use(route.get('/post/:id', show));
app.use(route.post('/post', create));
//链式写法
var router = require('koa-router')();
router.get('/', list)
.get('/post/new', add)
.get('/post/:id', show)
.post('/post', create);
app.use(router.routes())
.use(router.allowedMethods());
视图 Views
Express框架自身集成了视图功能，提供了consolidate.js功能，可以是有几乎所有Javascript模板引擎，并提供了视图设置的便利方法。Koa需要引入co-views中间件，co-views也是基于consolidate.js，支持能力一样强大。
// Express
// 这只模板路径和默认的模板后缀
app.set('views', __dirname + '/tpls');
app.set('view engine', 'html');
//默认，express根据template的后缀自动选择模板
//引擎渲染，支持jade和ejs。如果不使用默认扩展名
app.engine(ext, callback)
app.engine('html', require('ejs').renderFile);
//如果模板引擎不支持(path, options, callback)
var engines = require('consolidate');
app.engine('html', engines.handlebars);
app.engine('tpl', engines.underscore);
app.get('list', function(res, req){
res.render('list', {data});
//需要引入co-views中间件
var views = require('co-views');
var render = views('tpls', {
map: { html: 'swig' },//html后缀使用引擎
default: &jade&//render不提供后缀名时
var userInfo = {
name: 'tobi',
species: 'ferret'
html = render('user', { user: userInfo });
html = render('user.jade', { user: userInfo });
html = render('user.ejs', { user: userInfo });
返回 HTTP Response
获取完请求参数、处理好了具体的请求、视图也准备就绪，下面就该返回给客户端了，那就是HTTP Response对象了。这部分也属于框架的基础部分，各种都做了封装实现，显著的区别是koa直接将输出绑定到了ctx.body属性上，另外输出JSON或JSONP需要引入中间件。
// Express
//输出普通的html
res.render('tplName', {data});
//输出JSON
res.jsonp({ user: 'Samoay' });
// =& { &user&: &Samoay& }
//输出JSONP
?callback=foo
res.jsonp({ user: 'Samoay' });
// =& foo({ &user&: &Samoay& });
//res.send([body]);
res.send(new Buffer('whoop'));
res.send({ some: 'json' });
res.send('&p&some html&/p&');
//设定HTTP Status状态码
res.status(200);
//koa直接set ctx的status和body
app.use(route.get('/post/update/:id', function *(id){
this.status = 404;
this.body = 'Page Not Found';
var views = require('co-views');
var render = views('tpls', {
default: &jade&//render不提供后缀名时
app.use(route.get('/post/:id', function *(id){
var post = getPost(id);
this.status = 200;//by default, optional
this.body = yield render('user', post);
var json = require('koa-json');
app.use(route.get('/post/:id', function *(id){
this.body = {id:1234, title:&Test post&, content:&...&};
中间件 Middleware
对比了主要的几个框架功能方面的使用，其实区别最大，使用方式最不同的地方是在中间件的处理上。Express由于是在ES6特性之前的，中间件的基础原理还是callback方式的；而koa得益于generator特性和co框架（co会把所有generator的返回封装成为Promise对象），使得中间件的编写更加优雅。
// req 用于获取请求信息， ServerRequest 的实例
// res 用于响应处理结果， ServerResponse 的实例
// next() 函数用于将当前控制权转交给下一步处理，
如果给 next() 传递一个参数时，表示出错信息
var x = function (req, res, next) {
// 对req和res进行必要的处理
// 进入下一个中间件
return next();
// 传递错误信息到下一个中间件
return next(err);
// 直接输出，不再进入后面的中间件
return res.send('show page');
// koa 一切都在ctx对象上+generator
app.use(function *(){
this; // is the Context
this. // is a koa Request
this. // is a koa Response
this.// is node js request
this.// is node js response
//不再进入后面的中间件, 回溯upstream
该文章来自于阿里巴巴技术协会（
作者：金鸿
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致OurJS-我们的JS, 我们的技术-IT文摘; 专注JS相关领域;
我们热爱编程, 我们热爱技术;我们是高大上, 有品味的码农;
欢迎您订阅我们的技术周刊
我们会向您分享我们精心收集整理的，最新的行业资讯，技术动态，外文翻译，热点文章;
我们使用第三方邮件列表向您推送，我们不保存您的任何个人资料，注重您的隐私，您可以随时退订,
欢迎分享您的观点，经验，技巧，心得
让我们一起找寻程序员的快乐，探索技术, 发现IT人生的乐趣;
本网站使用缓存技术每次加载仅需很小流量, 可在手机中流畅浏览;
如果您发现任何BUG，请即时告知我们： ourjs(
订阅邮件周刊
［译］Node.js 框架比较: Express vs. Koa vs. Hapi
注意 转载须保留原文链接，译文链接，作者译者等信息。&&
1 介绍Express.js无疑是当前Node.js中最流行的Web应用程序框架。它几乎成为了大多数Node.js web应用程序的基本的依赖，甚至一些例如Sails.js这样的流行的框架也是基于Express.js。然而你还有一些其他框架的选择，可以给你带来“sinatra”一样的感觉（译注：sinatra是一个简单的Ruby的Web框架，可以参考）。另外两个最流行的框架分别是Koa和Hapi。这篇文章不是打算说服你哪个框架比另外一个更好，而是只是打算让你更好地理解每个框架能做什么，什么情况下一个框架可以秒杀另外一个。2 框架的背景我们将要探讨的两个框架看起来都非常相似。每一个都能够用几行代码来构建一个服务器，并都可以非常轻易地构建REST API。我们先瞧瞧这几个框架是怎么诞生的。2.1 Express2.1 Express日，TJ Holowaychuk提交了Express的第一次commit，接下来在日，有660次commits的Express 0.0.1版本正式发布。TJ和Ciaron Jessup是当时最主要的两个代码贡献者。在第一个版本发布的时候，根据github上的readme.md，这个框架被描述成：疯一般快速（而简洁）的服务端JavaScript Web开发框架，基于Node.js和V8 JavaScript引擎。差不多5年的时间过去了，Express拥有了4,925次commit，现在Express的最新版本是4.10.1，由StrongLoop维护，因为TJ现在已经跑去玩Go了。2.2 Koa大概在差不多一年前的日，TJ Holowaychuk（又是他！）只身一人提交了Koa的第一次commit。他描述Koa为“表现力强劲的Node.js中间件，通过使用generators使得编写web应用程序和REST API更加丝般顺滑”。Koa被标榜为只占用约400行源码空间的框架。Koa的目前最新版本为0.13.0，拥有583次commits。2.3 Hapi日，WalmartLabs的一位成员Eran Hammer提交了Hapi的第一次commit。Hapi原本是Postmile的一部分，并且最开始是基于Express构建的。后来它发展成自己自己的框架，正如Eran在他的博客里面所说的：Hapi基于这么一个想法：配置优于编码，业务逻辑必须和传输层进行分离..Hapi最新版本为7.2.0，拥有3,816次commits，并且仍然由Eran Hammer维护。所有开发者要开发Node.js web应用程序的第一步就是构建一个基本的服务器。所以我们来看看用这几个框架构建一个服务器的时候有什么异同。3 创建一个服务器所有开发者要开发Node.js web应用程序的第一步就是构建一个基本的服务器。所以我们来看看用这几个框架构建一个服务器的时候有什么异同。3.1 Expressvar express = require('express');
var app = express();
var server = app.listen(3000, function() {
console.log('Express is listening to http://localhost:3000');
对于所有的node开发者来说，这看起来相当的自然。我们把express require进来，然后初始化一个实例并且赋值给一个为app的变量。接下来这个实例初始化一个server监听特定的端口，3000端口。app.listen()函数实际上包装了node原生的http.createServer()函数。3.2 Koavar koa = require('koa');
var app = koa();
var server = app.listen(3000, function() {
console.log('Koa is listening to http://localhost:3000');
});你马上发现Koa和Express是很相似的。其实差别只是你把require那部分换成koa而不是express而已。app.listen()也是和Express一模一样的对原生代码的封装函数。3.3 Hapivar Hapi = require('hapi');
var server = new Hapi.Server(3000);
server.start(function() {
console.log('Hapi is listening to http://localhost:3000');
Hapi是三者中最独特的一个。和其他两者一样，hapi被require进来了但是没有初始化一个hapi app而是构建了一个server并且指定了端口。在Express和Koa中我们得到的是一个回调函数而在hapi中我们得到的是一个新的server对象。一旦我们调用了server.start()我们就开启了端口为3000的服务器，并且返回一个回调函数。这个server.start()函数和Koa、Express不一样，它并不是一个http.CreateServer()的包装函数，它的逻辑是由自己构建的。4 路由控制现在一起来搞搞一下服务器最重要的特定之一，路由控制。我们先用每个框架分别构建一个老掉渣的“Hello world”应用程序，然后我们再探索一下一些更有用的东东，REST API。4.1 Hello world4.1.1 Expressvar express = require('express');
var app = express();
app.get('/', function(req, res) {
res.send('Hello world');
var server = app.listen(3000, function() {
console.log('Express is listening to http://localhost:3000');
我们用get()函数来捕获“GET /”请求然后调用一个回调函数，这个回调函数会被传入req和res两个对象。这个例子当中我们只利用了res的res.send()来返回整个页面的字符串。Express有很多内置的方法可以用来进行路由控制。get,&post,&put,&head,&delete等等这些方法都是Express支持的最常用的方法（这只是一部分而已，并不是全部）。4.1.2 Koavar koa = require('koa');
var app = koa();
app.use(function *() {
this.body = 'Hello world';
var server = app.listen(3000, function() {
console.log('Koa is listening to http://localhost:3000');
Koa和Express稍微有点儿不同，它用了ES6的generators。所有带有*前缀的函数都表示这个函数会返回一个generator对象。根本上来说，generator会同步地yield出数据（译注：如果对Python比较熟悉的话，应该对ES6的generator不陌生，这里的yield其实和Python的yield语句差不多一个意思），这个超出本文所探索的内容，不详述。在app.use()函数中，generator函数设置响应体。在Koa中，this这个上下文其实就是对node的request和response对象的封装。this.body是KoaResponse对象的一个属性。this.body可以设置为字符串, buffer, stream, 对象, 或者null也行。上面的例子中我们使用了Koa为数不多的中间件的其中一个。这个中间件捕获了所有的路由并且响应同一个字符串。4.1.3 Hapivar Hapi = require('hapi');
var server = new Hapi.Server(3000);
server.route({
method: 'GET',
path: '/',
handler: function(request, reply) {
reply('Hello world');
server.start(function() {
console.log('Hapi is listening to http://localhost:3000');
这里使用了server对象给我们提供的server.route内置的方法，这个方法接受配置参数：path（必须），method（必须），vhost，和handler（必须）。HTTP方法可以处理典型的例如GET、PUT、POST、DELETE的请求，*通配符可以匹配所有的路由。handler函数被传入一个request对象的引用，它必须调用reply函数包含需要返回的数据。数据可以是字符串、buffer、可序列化对象、或者stream。4.2 REST APIHello world除了给我们展示了如何让一个应用程序运行起来以外几乎啥都没干。在所有的重数据的应用程序当中，REST API几乎是一个必须的设计，并且能让我们更好地理解这些框架是可以如何使用的。现在让我们看看这些框架是怎么处理REST API的。4.2.1 Expressvar express = require('express');
var app = express();
var router = express.Router();
// REST API
router.route('/items')
.get(function(req, res, next) {
res.send('Get');
.post(function(req, res, next) {
res.send('Post');
router.route('/items/:id')
.get(function(req, res, next) {
res.send('Get id: ' + req.params.id);
.put(function(req, res, next) {
res.send('Put id: ' + req.params.id);
.delete(function(req, res, next) {
res.send('Delete id: ' + req.params.id);
app.use('/api', router);
app.get('/', function(req, res) {
res.send('Hello world');
var server = app.listen(3000, function() {
console.log('Express is listening to http://localhost:3000');
});4.2.1 Expressvar express = require('express');
var app = express();
var router = express.Router();
// REST API
router.route('/items')
.get(function(req, res, next) {
res.send('Get');
.post(function(req, res, next) {
res.send('Post');
router.route('/items/:id')
.get(function(req, res, next) {
res.send('Get id: ' + req.params.id);
.put(function(req, res, next) {
res.send('Put id: ' + req.params.id);
.delete(function(req, res, next) {
res.send('Delete id: ' + req.params.id);
app.use('/api', router);
app.get('/', function(req, res) {
res.send('Hello world');
var server = app.listen(3000, function() {
console.log('Express is listening to http://localhost:3000');
我们为已有的Hello World应用程序添加REST API。Express提供一些处理路由的便捷的方式。这是Express 4.x的语法，除了你不需要express.Router()和不能用app.user('/api', router)以外，其实上是和Express 3.x本质上是一样的。在Express 3.x中，你需要用app.route()替换router.route()并且需要加上/api前缀。Express 4.x的这种语法可以减少开发者编码错误并且你只需要修改少量代码就可以修改HTTP方法规则。4.2.2 Koavar koa = require('koa');
var route = require('koa-route');
var app = koa();
// REST API
app.use(route.get('/api/items', function*() {
this.body = 'Get';
app.use(route.get('/api/items/:id', function*(id) {
this.body = 'Get id: ' +
app.use(route.post('/api/items', function*() {
this.body = 'Post';
app.use(route.put('/api/items/:id', function*(id) {
this.body = 'Put id: ' +
app.use(route.delete('/api/items/:id', function*(id) {
this.body = 'Delete id: ' +
// all other routes
app.use(function *() {
this.body = 'Hello world';
var server = app.listen(3000, function() {
console.log('Koa is listening to http://localhost:3000');
很明显，Koa并没有类似Express这样的可以减少编码重复路由规则的能力。它需要额外的中间件来处理路由控制。我选择使用koa-route因为它是由Koa团队维护的，但是还有很多由其他开发者维护的可用的中间件。Koa的路由和Express一样使用类似的关键词来定义它们的方法，.get(),&.put(),.post(), 和&.delete()。Koa在处理路由的时候有一个好处就是，它使用ES6的generators函数来减少对回调函数的处理。4.2.3 Hapivar Hapi = require('hapi');
var server = new Hapi.Server(3000);
server.route([
method: 'GET',
path: '/api/items',
handler: function(request, reply) {
reply('Get item id');
method: 'GET',
path: '/api/items/{id}',
handler: function(request, reply) {
reply('Get item id: ' + request.params.id);
method: 'POST',
path: '/api/items',
handler: function(request, reply) {
reply('Post item');
method: 'PUT',
path: '/api/items/{id}',
handler: function(request, reply) {
reply('Put item id: ' + request.params.id);
method: 'DELETE',
path: '/api/items/{id}',
handler: function(request, reply) {
reply('Delete item id: ' + request.params.id);
method: 'GET',
path: '/',
handler: function(request, reply) {
reply('Hello world');
server.start(function() {
console.log('Hapi is listening to http://localhost:3000');
对于Hapi路由处理的第一印象就是，相对于其它两个框架，这货是多么的清爽，可读性是多么的棒！即使是那些必须的method，path，handler和reply配置参数都是那么的赏心悦目（译注：作者高潮了）。类似于Koa，Hapi很多重复的代码会导致更大的出错多可能性。然而这是Hapi的有意之为，Hapi更关注配置并且希望使得代码更加清晰和让团队开发使用起来更加简便。Hapi希望可以不需要开发者进行编码的情况下对错误处理进行优化。如果你尝试去访问一个没有被定义的REST API，它会返回一个包含状态码和错误的描述的JSON对象。5 优缺点比较5.1 Express5.1.1 优点Express拥有的社区不仅仅是上面三者当中最大的，并且是所有Node.js web应用程序框架当中最大的。在经过其背后差不多5年的发展和在StrongLoop的掌管下，它是三者当中最成熟的框架。它为服务器启动和运行提供了简单的方式，并且通过内置的路由提高了代码的复用性。5.1.2 缺点使用Express需要手动处理很多单调乏味的任务。它没有内置的错误处理。当你需要解决某个特定的问题的时候，你会容易迷失在众多可以添加的中间件中，在Express中，你有太多方式去解决同一个问题。Express自诩为高度可配置，这有好处也有坏处，对于准备使用Express的刚入门的开发者来说，这不是一件好的事情。并且对比起其他框架来说，Express体积更大。5.2 Koa5.2.1 优点Koa有着傲人的身材（体积小），它表现力更强；对比起其他框架，它使得中间件的编写变的更加容易。Koa基本上就是一个只有骨架的框架，你可以选择（或者自己写一个）中间件，而不用妥协于Express或者Hapi它们自带的中间件。它也是唯一一个采用ES6的框架，例如它使用了ES6的generators。5.2.2 缺点Koa不稳定，仍处于活跃的开发完善阶段。使用ES6还是有点太超前了，例如只有0.11.9+的Node.js版本才能运行Koa，而现在最新的Node.js稳定版本是0.10.33。和Express一样有好也有坏的一点就是，在多种中间件的选择还是自己写中间件。就像我们之前所用的router那样，有太多类似的router中间件可供我们选择。5.3 Hapi5.3.1 优点Hapi自豪地宣称它自己是基于配置优于编码的概念，并且很多开发者认为这是一件好事。在团队项目开发中，可以很容易地增强一致性和可复用性。作为有着大名鼎鼎的WalmartLabs支持的框架和其他响当当的企业在实际生产中使用Hapi，它已经经过了实际战场的洗礼，企业们可以没有担忧地基于Hopi运行自己的应用程序。所有的迹象都表明Hapi向着成为的伟大的框架的方向持续成熟。5.3.2 缺点Hapi绝逼适合用来开发更大更复杂的应用。但对于一个简单的web app来说，它的可能有点儿堆砌太多样板代码了。而且Hapi的可供参考样例太少了，或者说开源的使用Hapi的应用程序太少了。所以选择它对开发者的要求更高一点，而不是所使用的中间件。6 总结我们已经看过三个框架一些棒棒的而且很实际的例子了。Express毫无疑问是三个当中最流行和最出名的框架。当你要开发一个新的应用程序的时候，使用Express来构建一个服务器可能已经成为了你的条件反射了；但希望现在你在做选择的时候会多一些思考，可以考虑选择Koa或者Hapi。Koa通过超前拥抱ES6和Web component的思想，显示了Web开发社区正在进步的对未来的承诺。对于比较大的团队和比较大的项目来说，Hapi应该成为首要选择。它所推崇的配置优于编码，对团队和对团队一直追求的可复用性都大有裨益。现在赶紧行动起来尝试使用一个新的框架，可能你会喜欢或者讨厌它，但没到最后你总不会知道结果是怎么样的，有一点无容置疑的是，它会让你成为一个更好的开发者。英文原文：作者：Jonathan译者：戴嘉华译文：戴嘉华,
&热门文章 - 分享最多
&相关阅读 - 心得体会
&关键字 - Node.JS
&欢迎订阅 - 技术周刊
我们热爱编程, 我们热爱技术; 我们是高端, 大气, 上档次, 有品味, 时刻需要和国际接轨的码农; 欢迎您订阅我们的技术周刊; 您只需要在右上角输入您的邮箱即可; 我们注重您的隐私，您可以随时退订.
加入我们吧! 让我们一起找寻码农的快乐，探索技术, 发现IT人生的乐趣;
我们的微信公众号: ourjs-com
打开微信扫一扫即可关注我们:
IT文摘-程序员(码农)技术周刊