什么是设计模式
A design pattern is a general, reusable solution to a commonly occurring problem.
单例模式
单例模式将“类”的实例的个数限制为一个。在Node.js中创建单例模式非常的简单，只需要用require即可。
//area.js
var PI = Math.PI;
function circle (radius) {
return radius * radius * PI;
}
module.exports.circle = circle;
无论你在应用中require这个模块多少次，这个模块的实例只会有一份存在。
var areaCalc = require('./area');
console.log(areaCalc.circle(5));
正因为require的这种行为，单例模式很可能是NPM模块中最常见的Node.js设计模式。
观察者模式
一个对象维护着一个依赖/观察者列表，并在状态改变的时候自动的通知列表中的每个成员。要实现观察者模式，可以借助于EventEmitter。
// MyFancyObservable.js
var util = require('util');
var EventEmitter = require('events').EventEmitter;
function MyFancyObservable() {
EventEmitter.call(this);
}
util.inherits(MyFancyObservable, EventEmitter);
这样我们就创建了一个可被观察的对象。为了让它更有用，我们可以为它增加点功能：
MyFancyObservable.prototype.hello = function (name) {
this.emit('hello', name);
};
太好了，现在我们的观测者可以发出事件（emit event）了，让我们来试下：
var MyFancyObservable = require('MyFancyObservable');
var observable = new MyFancyObservable();
observable.on('hello', function (name) {
console.log(name);
});
observable.hello('john');
工厂模式
工厂模式使我们不需要使用构造器，而是通过提供一个泛型（通用）接口来创建对象。这种模式在创建过程变得复杂时会非常有用。
function MyClass (options) {
this.options = options;
}
function create(options) {
// modify the options here if you want
return new MyClass(options);
}
module.exports.create = create;
工厂也使得测试变得更加简单，因为你可以通过这种模式来注入模块的依赖。
依赖注入
Dependency injection is a software design pattern in which one or more dependencies (or services) are injected, or passed by reference, into a dependent object.
在下面的例子中，我们将创建一个获取数据库依赖的UserModel类。
function userModel (options) {
var db;
if (!options.db) {
throw new Error('Options.db is required');
}
db = options.db;
return {
create: function (done) {
db.query('INSERT ...', done);
}
}
}
module.exports = userModel;
然后，我们可以使用如下方法创建实例：
var db = require('./db');
var userModel = require('User')({
db: db
});
为什么这很有用？因为这使得测试变得简单，当你写单元测试的时候，你可以很容易的注入一个假db对象到你的模型中。
Middlewares/ pipelines
中间件的概念很简单但却非常强大：一个单元/函数的输出是下一个的输入。如果你曾用过Express或Koa那么你肯定接触过。
我们来看看在Koa中是怎么做的：
app.use = function(fn){
this.middleware.push(fn);
return this;
};
也就是说，当你使用一个中间件的时候，它会被push到middleware数组中，这非常的赞，但是当请求到达服务器的时候发生了什么呢？
var i = middleware.length;
while (i--) {
next = middleware[i].call(this, next);
}
原来没什么神奇的地方，你的中间件只不过是依次被循环遍历的调用了而已。
Streams
你可以将流想象成一个特殊的管道。它们更擅长处理大量的流动数据，即使是它们是字节而不是对象。
process.stdin.on('readable', function () {
var buf = process.stdin.read(3);
console.dir(buf);
process.stdin.read(0);
});
调用
$ (echo abc; sleep 1; echo def; sleep 1; echo ghi) | node consume2.js <Buffer 61 62 63> <Buffer 0a 64 65> <Buffer 66 0a 67> <Buffer 68 69 0a>
转载请注明： 文章转载自：爱思资源网 http://www.aseoe.com/show-70-642-1.html
