JavsScript中对象继承关系变得无关紧要，对于一个对象来说重要的是它能做什么，而不是它从哪里来。
JavaScript提供了一套更为丰富的代码重用模式。它可以模拟那些基于类的模式，同时它也可以支持其他更具表现力的模式。
JavaScript是一门基于原型的语言，这意味着对象直接从其他对象继承。
一、伪类
1、原理
javascript原型机制：不直接让对象从其他对象继承，反而插入了一个多余的间接层：通过构造器函数产生对象。
当一个函数对象被创建时，Function构造器产生的函数对象会运行类型这样一些代码：
this.prototype={constructor:this}
新函数对象被赋予一个prototype属性，它的值是一个包含constructor属性且属性值为该新函数的对象。这个prototype对象是存放继承特征的地方。
当采用构造器调用模式，即用new前缀去调用一个函数时，函数执行的方式会被修改。如果new运算符是一个方法而不是一个运算符，它可能会像这样执行：
Function.method('new',function () {
//创建一新对象，它继承自构造器函数的原型对象。
var that=Object.create(this.prototype);
//调用构造器函数，绑定-this-到新对象上。
var other=this.apply(that,arguments);
//如果它的返回值不是一个对象，就返回该对象。
return (typeof other==='object'&&other)||that;
});
2、伪类，即使用new前缀
定义一构造器并扩充它的原型：
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"
构造另一个伪类来继承Mamal，这是通过定义它的constructor函数并替换它的prototype为一个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"
伪类模式本意是想向面向对象靠拢，但它看起来格格不入。
我们隐藏一些丑陋的细节，通过使用method方法来定义一个inherits方法实现。
Function.prototype.method=function(name,func){ if(!this.prototype[name]){ this.prototype[name]=func; } return this; } Function.method('inherits',function(Parent){ this.prototype=new Parent(); return this; }); var Cat=function(name){ this.name=name; this.saying='meow' } .inherits(Mammal) .method('purr',function(n){ var i,s=''; for(i=0;i<n;i+=1){ if(s){ s+='-' } s+='r'; } return s; }) .method('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"
问题：以上虽然隐藏了prototype操作细节，但是问题还在：有了像“类” 的构造器函数，但仔细看它们，你会惊讶地发现：
1、没有私有环境，所有的属性都是公开的。
2、使用构造器函数存在一个严重的危害。如果调用构造函数时忘记了在前面加上new前缀，那么this将不会被绑定到一个新对象上。悲剧的是，this将被绑定到全局对象上，所以你不但没有扩充新对象，反而破坏了全局变量环境。
这是一个严重的语言设计错误。为了降低这个问题带来的风险，所有的构造器函数都约定命名成首字母大写的形式，并且不以首字母大写的形式拼写任何其他的东西。
一个更好的备选方案就是根本不使用new。
二、对象说明符
构造器要接受一大串参数，要记住参数的顺序非常困难。所以编写构造器时让它接受一个简单的对象说明符，更友好。
//接受一大串参数 var myObject=maker(f,l,m,c,s); //对象字面量更友好 var myObject=maker({ first:f, middle:m, last:l, state:s, city:c });
对象字面量好处：
- 多个参数可以按任何顺序排列
- 构造器如果聪明的使用了默认值，一些参数可以忽略掉
- 和JSON一起用时，可以把JSON对象传给构造器，返回一个构造完全的对象
三、原型
原型模式中，摒弃类，转而专注于对象。概念：一个新对象可以继承一个旧对象的属性。 通过构造一个有用的对象开始，接着可以构造更多和那个对象类似的对象。这就可以完全避免把一个应用拆解成一系列嵌套抽象类的分类过程。
1、差异化继承
用对象字面量构造一个有用的对象。
var myMammal={ name:"Herb the Mammal", get_name:function(){ return this.name; }, says:function(){ return this.saying || ''; } }
一旦有了想要的对象，就可以利用Object.create方法构造出更多的实例。
var myCat=Object.create(myMammal); myCat.name='Henrietta'; myCat.saying='meow'; myCat.purr=function(n){ var i,s=''; for(i=0;i<n;i++){ if(s){ s+='-'; } s+='r'; } return s; } myCat.get_name=function(){ return this.says+' '+this.name+' '+this.says; }
这是一种“差异化继承（differential inheritance）”，通过定制一新的对象，我们指明它与所基于的基本对象的区别。
2、差异化继承优势
差异化继承，对某些数据结构继承于其他数据结构的情形非常有用。
例：假定我们要解析一门类似JavaScript这样用一对花括号指示作用域的语言。定义在某个作用域里的条目在该作用域外是不可见的。
但在某种意义上，一个内部作用域会继承它的外部作用域。JavaScript在表示这样的关系上做得非常好。
当遇到一个左花括号时block函数被调用，parse函数将从scope中寻找符号，并且它定义了新的符号时扩充scope。
var block=function(){ //记住当前的作用域。构造一包含了当前作用域中所有对象的新的作用域 var oldScope=scope; scope=Object.create(scope); //传递左花括号作为参数调用advance advance('{'); //使用新的作用域进行解析 parse(scope); //传递右花括号作为参数调用advance并抛弃新作用域，恢复原来老的作用域 advance('}'); scope=oldScope; }
四、函数化
至此，上面我们看到的继承模式的一个弱点就是：没法包含隐私。对象的所有属性都是可见的。
应用模块模式，可以解决这个问题。
1、模块模式
从构造一个生成对象的函数开始。我们以小写字母开头来命名它，因为它并不需要使用new前缀。该函数包括4个步骤：
- 创建一个新对象。有很多的方式去构造一个对象
- 对象字面量构造
- new调用一个构造器函数
- Object.create方法构造一个已经尽的对象的新实例
- 调用任意一个会返回一个对象的函数
- 有选择性地定义私有实例变量和方法。这些就是函数中通过var 语句定义的普通变量。
- 给这个新对象扩充方法。这些方法拥有特权去访问参数，以及在第二步中通过var语句定义的变量。
- 返回那个新对象。
下面是一个函数化构造器的伪代码模板（加粗的文本表示强调）：
var constructor =function(spec,my){ var that,其他私有实例变量； my=my||{}; 把共享的变量和函数添加到my中 that=一个新对象 添加给that的特权方法 return that; }
说明：
spec对象包含构造器需要构造一新实例的所有信息。spec的内容可能被复制到私有变量中，或者被其他函数改变，或者方法可以在需要的时候访问spec的信息。（一个简化的方式是替换spec为一个单一的值。当构造对象过程汇总并不需要整个spec对象的时候，这是有用的）
my对象是一个为继承链中的构造器提供秘密共享的容器。 my对象可以选择性地使用。如果没有传入一个my对象，那么会创建一个my对象。
接下来，声明该对象私有的实例变量和方法。 通过简单的声明变量就可以做到。构造器的变量和内部函数变成了该实例的私有成员。内部函数可以访问spec，my,that，以及其他私有变量。
接下来，给my变量添加共享的秘密成员。这是通过赋值语句来实现的：
my.member=value；
现在，我们构造了一个新对象并把它赋值给that。构造新对象可能是通过调用函数化构造器，传给它一个spec对象（可能就是传递给当前构造器的同一个spec对象）和my对象。my对象允许其他的构造器分享我们放到my中的资料。其他的构造器可能也会把自己可分享的秘密成员放进my对象里，以便我们的构造器可以利用它。
接下来，扩充that，加入组成该对象接口的特权方法。我们可以分配一个新函数称为that的成员方法。或者，更安全地，我们可以先把函数定义为私有方法，然后再把它们分配给that：
var methodical=function(){
...
};
that.methodical=methodical;
/*分开两步去定义methodical的好处是，如果其他方法想要调用methodical，它们可以直接调用methodical()而不是that.methodical()。 如果该实例被破坏或篡改，甚至that.methodical被替换掉了， 调用methodical的方法同样会继续工作，因为它们私有的methodical不受该实例被修改的影响。*/
2、应用
我们把这个模式应用到mammal例子里。此处不需要my，所以我们先抛开它，但会使用一个spec对象。
var mammal=function(spec){ var that={}; that.get_name=function(){ return spec.name; }; that.says=function(){ return spec.saying || ''; } return that; } var myMammal=mammal({name:'Herb'});
此时name就是私有属性，被保护起来了。
在伪类模式里，构造器函数Cat不得不重复构造器Mammal已经完成的工作。在函数化模式中那不再重要了，因为构造器Cat将会调用构造器Mammal，让Mammal去做对象创建中的大部分工作，所以Cat只需关注自身的差异即可。
var cat=function(spec){ spec.saying=spec.saying || 'meow'; var that=mammal(spec); that.purr=function(n){ var i,s=''; for(i=0;i<n;i++){ if(s){ s+='-'; } s+='r'; } return s; }; that.get_name=function(){ return that.says()+' '+spec.name+' '+that.says(); }; return that; } var myCat=cat({name:'Henrietta'});
函数化模式还给我们提供了一个处理父类方法的方法。
我们会构造一个superior方法，它取得一个方法名并返回调用那个方法的函数。该函数会调用原来的方法，尽管属性已经变化了。
/*有点难理解*/
Object.method('superior',function(name){ //传入方法名name
var that=this,method=that[name];
return function(){
return method.apply(that,argumetns);
}
});
把调用superior应用在coolcat上， coolcat就像cat一样，除了它有一个更酷的调用父类cat的方法的get_name方法。
它只需要一点点准备工作。我们会声明一个super_get_name变量，并且把调用superior方法所返回的结果赋值给它。
var coolcat=function(spec){ //coolcat有一个更酷的调用父类cat的方法的get_name方法 var that=cat(spec); var super_get_name=that.superior('get_name'); that.get_name=function(n){ return 'like '+super_get_name()+'baby'; } return that; } var myCoolCat=coolcat({name:'Bix'}); var name=myCoolCat.get_name();//"like meow Bix meowbaby"
函数模块化有很大的灵活性。它相比伪类模式不仅带来的工作更少，还让我们得到更好的封装和信息隐藏，以及访问父类方法的能力。
/*有点难理解*/
如果对象的所有状态都是私有的，那么该对象就称为了一个“防伪（tamper-proof）对象” 。该对象的属性可以被替换或删除，但该对象的完整性不会受到损害。
如果我们用函数化的模式创建一个对象，并且该对象的所有方法都不使用this或that，那么该对象就是持久性(durable)的。
一个持久性的对象不会被入侵。访问一个持久性的对象时，除非有方法授权，否则攻击者不能访问对象的内部状态。
总结一下以上整个完美的继承链的代码：
<script> /* *****mammal object***** */ var mammal=function(spec){ var that={}; that.get_name=function(){ return spec.name; }; that.says=function(){ return spec.saying || ''; } return that; } //call var myMammal=mammal({name:'Herb'}); /* *****cat object***** */ var cat=function(spec){ spec.saying=spec.saying || 'meow'; var that=mammal(spec); that.purr=function(n){ var i,s=''; for(i=0;i<n;i++){ if(s){ s+='-'; } s+='r'; } return s; }; that.get_name=function(){ return that.says()+' '+spec.name+' '+that.says(); }; return that; } //call var myCat=cat({name:'Henrietta'}); /*user-defined Method*/ Function.prototype.method=function(name,func){ if(!this.prototype[name]){ this.prototype[name]=func; } return this; } Object.method('superior',function(name){ //传入方法名name var that=this,method=that[name]; return function(){ return method.apply(that,arguments); } }); /* *****coolcat object***** */ var coolcat=function(spec){ //coolcat有一个更酷的调用父类cat的方法的get_name方法 var that=cat(spec); var super_get_name=that.superior('get_name'); that.get_name=function(n){ return 'like '+super_get_name()+'baby'; } return that; } //call var myCoolCat=coolcat({name:'Bix'}); var name=myCoolCat.get_name();//"like meow Bix meowbaby" </script>
五、部件(Parts)
我们可以从一套部件中把对象组装出来。
例如，我们可以构造一个给任何对象添加简单事件处理特性的函数。它会给对象添加一个on方法，一个fire方法和一个私有的事件注册表对象：
<script> 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++){ handler=array[i]; //每个处理程序包含一个方法和一组可选的参数。 //如果该方法是一个字符串形式的名称，那么寻找到该函数。 func=handler.method; if(typeof func==='string'){ func=this[func]; } //调用一个处理程序。如果该条目包含参数，那么传递它们过去。否则，传递该事件对象。 func.apply(this,handler.paramenters || [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; } </script>
我们可以在任何单独的对象上调用eventuality，授予它事件处理方法。 我们也可以赶在that被返回前在一个构造器函数中调用它。eventlity(that);
用这种方式，一个构造器函数可以从一套布局中把对象组装出来。JavaScript的弱类型在此处是一个巨大的优势，因为我们无须花费精力去了解对象在类型系统中的继承关系。相反，我们只需要专注于它们的个性特征。
如果我们想要eventuality访问该对象的私有状态，可以把私有成员集my传递给它。
参考：
https://www.zybuluo.com/zhangzhen/note/77227
本文作者starof,因知识本身在变化，作者也在不断学习成长，文章内容也不定时更新，为避免误导读者，方便追根溯源，请诸位转载注明出处：http://www.cnblogs.com/starof/p/4904929.html有问题欢迎与我讨论，共同进步。