继承
JS不是基于类的，而是基于原型的，这意味着对象直接从其他对象继承。
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'
有时候构造器要接受一大串的参数。这可能是令人烦恼的，因为要记住参数的顺序可能非常困难。例如：
var myObject = maker(f,l,s,c);
不如这么写：
var myObject = maker({ first:f, last:l, state:s, city:c });
现在多个参数可以按任何顺序排列，如果构造器会聪明地使用默认值，一些参数可以忽略掉，并且代码也更容易阅读。
在一个纯粹的原型模式中，我们会摒弃类，转而专注于对象。基于原型的继承相比基于类的继承在概念上更为简单：一个新对象可以继承一个旧对象的属性。可以构造一个有用对象，接着构造更多和那个对象相似的对象。
用对象字面量构建一个有用的对象：
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( ); };
这是一种“差异化继承”。通过定制一个新的对象，我们指明了它与所基于的基本对象的区别。
函数化模式有很大的灵活性，能够更好的封装和隐藏信息。
构造一个产生对象的函数，给它起的名字以一个小写字母开头，因为它并不需要使用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; };
可以从一套部件中组合出对象来。例如：构造一个能够添加简单事件处理特性到任何对象上的函数。它会给对象添加一个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著 赵泽欣 鄢学鹍 译
转载请注明出处：