原型模式和基于原型继承的JavaScript对象系统

在以类为中心的面向对象编程语言中，类和对象的关系可以想象成铸模和铸件的关系，对象总是从类中创建而来的。而在原型编程的思想中，类并不是必须的，对象未必需要从类中创建而来，一个对象是通过克隆另外一个对象所得到的。
原型模式不单是一种设计模式，也被称为一种编程泛型。
原型模式的实现关键，是语言本身是否提供了clone方法。ECMAScript5提供了Object.create方法，可以用来克隆对象。

var Plane = function() {
    this.blood = 100;
    this.attackLevel = 1;
    this.defenseLevel = 1;
};
var plane = new Plane();
plane.blood = 500;
plane.attackLevel = 10;
plane.defenseLevel = 7;
var clonePlane = Object.create(plane);
console.log(clonePlane.blood);// 500
console.log(clonePlane.attackLevel);//10
console.log(clonePlane.defenseLevel);//7

在不支持Object.create方法的浏览器中，则可以使用以下代码：

Object.create = Object.create || function(obj) {
    var F = function(){};
    F.prototype = obj;
    return new F();
};

原型编程泛型至少包括一下基本规则：
所有的数据都是对象。
要得到一个对象，不是通过实例化类，而是找到一个对象作为原型并克隆它。
对象会记住它的原型。
如果对象无法响应某个请求，它会把这个请求委托给它自己的原型。
JavaScript中的原型继承
1、所有的数据都是对象
按照JavaScript设计者的本意，除了undefined之外，一切都应是对象。为了实现这一目标，number、boolean、string这几种基本类型数据也可以通过“包装类”的方式变成对象类型数据来处理。
我们不能说在JavaScript中所有的数据都是对象，但可以说绝大部分数据都是对象。那么相信在JavaScript中也一定会有一个根对象存在，这些对象追根溯源都来源于这个根对象。
事实上，JavaScript中的根对象是Object.prototype对象。Object.prototype对象是一个空的对象。我们在JavaScript遇到的每个对象，实际上都是从Object.prototype对象克隆而来的，Object.prototype对象就是它们的原型。
2、要得到一个对象，不是通过实例化类，而是找到一个对象作为原型并克隆它
在JavaScript中没有类的概念，JavaScript的函数既可以作为普通函数被调用，也可以作为构造器被调用。当使用new运算符来调用函数时，此时的函数就是一个构造器。用new运算符来创建对象的过程，实际上也只是先克隆Object.prototype对象，再进行一些其他额外操作的过程。
我们可以通过下面这段代码来理解new运算的过程：

function Person( name ) {
    this.name = name;
};
Person.prototype.getName = function() {
    return this.name;
};
var objectFactory = function() {
    var obj = new Object(), // 从Object.prototype上克隆一个空的对象
    Constructor = [].shift.call( arguments );// 取得外部传入的构造器，此例是Person
    obj._proto_ = Constructor.prototype;// 指向正确的原型
    var ret = Constructor.apply( obj, arguments );// 借用外部传入的构造器给obj设置属性
    return typeof ret === 'object' ? ret : obj;// 确保构造器总是会返回一个对象
};
var a = objectFactory( Person, 'sven' );
console.log( a.name );//sven
console.log( a.getName() );//sven
console.log(Object.getPrototypeOf(a) === Person.prototype); //true

我们看到了，分别调用下面两句代码产生了一样的结果：

var a = objectFactory( A, 'sven' );
var a = new A( 'sven' );

3、对象会记住它的原型
JavaScript给对象提供了一个名为proto的隐藏属性，某个对象的proto属性默认会 指向它的构造器的原型对象，即{ Constructor }.prototype。
实际上，proto就是对象跟“对象构造器的原型”联系起来的纽带。正因为对象要通过proto属性来记住它的构造器的原型，所以我们用前面objectFactory函数来模拟用new创建对象时，需要手动给obj对象设置正确的proto指向。

obj._proto_ = Constructor.prototype;
通过这段代码，我们让obj._proto_指向Person.prototype而不是原来的Object.prototype

4、如果对象无法响应某个请求，它会把这个请求委托给它的构造器的原型
虽然JavaScript的对象最初都是由Object.prototype对象克隆而来的，但对象构造器的原型并不仅限于Object.prototype上，而是可以动态指向其他对象。这样一来，当对象a需要借用对象b的能力时，可以有选择性的把对象a的构造器的原型指向对象b，从而达到继承的效果。
下面的代码是我们最常用的原型继承方式：

var obj = { name: 'sven' };
var A = function() {};
A.prototype = obj;
var a = new A();
console.log( a.name );// sven

我们来看看执行这段代码的时候，引擎做了哪些事情

• 首先尝试便利对象a中的所有属性，但没有找到name这个属性。
• 查找name属性的这个请求被委托给对象a的构造器的原型，它被a.proto记录着并且指向A.prototype，而A.prototype被设置为对象obj。
• 在对象obj中找到了name属性，并返回它的值

当我们期望得到一个“类”继承自另一个“类”的效果时，往往会用下面的代码来模拟实现：

var A = function() {};
A.prototype = { name: 'sven' };
var B = function() {};
B.prototype = new A();
var b = new B();
console.log(b.name);// sven

再看这段代码执行的时候，引擎做了什么事情

• 首先，尝试遍历对象b中的所有属性，但没有找到name这个属性。
• 查找name属性的请求被委托给对象b的构造器的原型，它被b.proto记录着并且指向B.prototype，而B.prototype被设置为一个通过new A()创建出来的对象。
• 在该对象中依然没有找到name属性，于是请求被继承委托给这个对象的构造器的原型A.prototype
• 在A.prototype中找到name属性，并返回它的值

和把B.prototype直接指向一个字面量对象相比，通过B.prototype = new A()形成的原型链比之前多了一层。但二者之间并没有本质上的区别，都是将对象构造器的原型指向另外一个对象，继承总是发生在对象和对象之间。