继承
JS不是基于类的，而是基于原型的，这意味着对象直接从其他对象继承。
1 伪类
JS提供了一套丰富的代码重用模式，它可以模拟那些基于类的模式，因为JS实际上没有类，所以把模拟的类称为伪类。
我们可以定义一个构造器并扩充它的原型：
var Mammal = function (name) {
this.name = name;
};
Mammal.prototype.get_name = function ( ) {
return this.name;
};
Mammal.prototype.says = function ( ) {
return this.saying || '';
};
现在可以构造一个实例：
var myMammal = new Mammal('Herb the Mammal');
var name = myMammal.get_name( ); // 'Herb the Mammal'
可以构造另一个伪类来继承Mammal：
var Cat = function (name) {
this.name = name;
this.saying = 'meow';
};
// 替换Cat.prototype 为一个新的 Mammal 实例
Cat.prototype = new Mammal( );
// 扩充新原型对象，添加purr和get_name方法
Cat.prototype.purr = function (n) {
var i, s = '';
for (i = 0; i < n; i += 1) {
if (s) {
s += '-';
}
s += 'r';
}
return s;
};
Cat.prototype.get_name = function ( ) {
return this.says( ) + ' ' + this.name +' ' + this.says( );
};
var myCat = new Cat('Henrietta');
var says = myCat.says( ); // 'meow'
var purr = myCat.purr(5); // 'r-r-r-r-r'
var name = myCat.get_name( ); // 'meow Henrietta meow'
2 对象说明符
有时候构造器要接受一大串的参数。这可能是令人烦恼的，因为要记住参数的顺序可能非常困难。例如：
var myObject = maker(f,l,s,c);
不如这么写：
var myObject = maker({
first:f,
last:l,
state:s,
city:c
});
现在多个参数可以按任何顺序排列，如果构造器会聪明地使用默认值，一些参数可以忽略掉，并且代码也更容易阅读。
3 原型
在一个纯粹的原型模式中，我们会摒弃类，转而专注于对象。基于原型的继承相比基于类的继承在概念上更为简单：一个新对象可以继承一个旧对象的属性。可以构造一个有用对象，接着构造更多和那个对象相似的对象。
用对象字面量构建一个有用的对象：
var myMammal = {
name : 'Herb the Mammal',
get_name : function ( ) {
return this.name;
},
says : function ( ) {
return this.saying || '';
}
};
为Object增加一个create方法，用来创建新的实例
if (typeof Object.create !== 'function') {
Object.create = function (o) {
var F = function () {};
F.prototype = o;
return new F();
};
}
定制一个新实例：
var myCat = Object.create(myMammal);
myCat.name = 'Henrietta';
myCat.saying = 'meow';
myCat.purr = function (n) {
var i, s = '';
for (i = 0; i < n; i += 1) {
if (s) {
s += '-';
}
s += 'r';
}
return s;
};
myCat.get_name = function ( ) {
return this.says( ) + ' ' + this.name + ' ' + this.says( );
};
这是一种“差异化继承”。通过定制一个新的对象，我们指明了它与所基于的基本对象的区别。
4 函数化
函数化模式有很大的灵活性，能够更好的封装和隐藏信息。
构造一个产生对象的函数，给它起的名字以一个小写字母开头，因为它并不需要使用new前缀。该函数包括4个步骤：
- 1.它创建一个新对象。有很多的方法去构造一个对象。它可以构造一个对象字面量，或者它可以和new 前缀连用去调用一个构造函数，或者它可以使用Object.beget方法去构造一个已经存在的对象的新实例，或者它可以调用任意一个返回一个对象的函数。
- 2.它选择性的定义私有实例变量和方法。这些就是函数中通过var语句定义的普通变量。
- 3.它给这个新对象扩充方法。这些方法荣有特权去访问参数，以及第二步中通过var语句定义的变量。
- 4.它返回一个新对象。
如下是一个函数化构造器的伪代码：
var constructor = function (spec, my) {
var that, 其他私有实例变量;
my = my || {};
把共享的变量和函数添加到my中
that = 一个新对象
添加给that的特权方法
return that;
};
5 部件
可以从一套部件中组合出对象来。例如：构造一个能够添加简单事件处理特性到任何对象上的函数。它会给对象添加一个on方法、一个fire方法和一个私有的事件注册表对象：
var eventuality = function (that) {
var registry = {};
that.fire = function (event) {
// 在一个对象上触发一个事件。该事件可以是一个包含事件名称的字符串，或者是一个拥有包含事件名称的type属性的对象。
//通过‘on’方法注册的事件处理程序中匹配事件名称的函数将被调用。
var array,
func,
handler,
i,
type = typeof event === 'string' ? event : event.type;
// 如果这个事件存在一组事件处理程序，那么就遍历它们并按顺序依次执行。
if (registry.hasOwnProperty(type)) {
array = registry[type];
for (i = 0; i < array.length; i += 1) {
handler = array[i];
//每个处理程序包含一个方法和一组可选参数。
//如果该方法是一个字符串形式的名字，那么就寻找到该函数。
func = handler.method;
if (typeof func === 'string') {
func = this[func];
}
// 调用一个处理程序，如果该条目包含参数，那么传递它们过去。否则，传递该事件对象。
func.apply(this,handler.parameters || [event]);
}
}
return this;
};
that.on = function (type, method, parameters) {
// 注册一个事件，构造一条处理程序条目，将它插入到处理程序数组中。
// 如果这种类型的事件还不存在，就构建一个。
var handler = {
method: method,
parameters: parameters
};
if (registry.hasOwnProperty(type)) {
registry[type].push(handler);
} else {
registry[type] = [handler];
}
return this;
};
return that;
};
我们可以在任何单独对象上调用eventuality，授予它事件处理方法。我们也可以赶在that被返回前在一个构造器函数中调用它。
eventuality(that);
用这种方式，一个构造器函数可以从一套部件中组装出对象来。
参考：《JavaScript语言精粹》Douglas Crockford著 赵泽欣 鄢学鹍 译
转载请注明出处：