Javascript原型链的原理
一、JavaScript原型链
ECMAScript中描述了原型链的概念，并将原型链作为实现继承的主要方法。其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。在JavaScript中，用__proto__属性来表示一个对象的原型链。当查找一个对象的属性时，JavaScript会向上遍历原型链，直到找到给定名称的属性为止！
比如现在有如下的代码：
扩展Object类，添加Clone和Extend方法
复制代码
1/扩展Object类，添加Clone，JS实现克隆的方法/
2Object.prototype.Clone=function(){
3varobjClone;
4if(this.constructor==Object){
5objClone=newthis.constructor();
6}else{
7objClone=newthis.constructor(this.valueOf());
8}
9for(varkeyinthis){
10if(objClone[key]!=this[key]){
11if(typeof(this[key])==''object''){
12objClone[key]=this[key].Clone();
13}else{
14objClone[key]=this[key];
15}
16}
17}
18objClone.toString=this.toString;
19objClone.valueOf=this.valueOf;
20returnobjClone;
21}
22
23/扩展Object类，添加Extend方法来实现JS继承,目标对象将拥有源对象的所有属性和方法/
24Object.prototype.Extend=function(objDestination,objSource){
25for(varkeyinobjSource){
26if(objSource.hasOwnProperty(key)&&objDestination[key]===undefined){
27objDestination[key]=objSource[key];
28}
29}
30returnobjDestination;
31}
复制代码
定义Person类
1/定义一个Person类/
2functionPerson(_name,_age){
3this.name=_name;
4this.age=_age;
5}
在JavaScript中，Object类是所有类的父类，所以Person类从Object类继承，继承了Object类的所有public属性和public方法，包括Object类新添加的Clone和Extend方法
可以用如下的代码证明，Person类确实是继承了Object类
复制代码
1document.write("");
2
3varp=newPerson("孤傲苍狼",24);//创建一个人，名字是孤傲苍狼
4varcloneP=p.Clone();//p调用在Object类中定义的Clone方法来克隆自己，如果能得到一个cloneP，那就证明了Person类确实是继承了Object类，所以就拥有了Clone
5document.writeln("p是使用Person类以构造函数的方式创建出来的对象，p.name="+p.name+"，p.age="+p.age);
6document.writeln("cloneP是p调用Clone方法克隆出来的对象，cloneP.name="+cloneP.name+"，cloneP.age="+cloneP.age);
7document.writeln("cloneP对象和p对象是两个相互独立的对象，这两个对象的内存地址肯定是不相等，p==cloneP的结果是："+(p==cloneP));
8cloneP.name="白虎神皇";//修改cloneP的名字
9document.writeln("cloneP的name被修改了，cloneP.name="+cloneP.name);
10document.writeln("cloneP的name修改了，但是不影响到p，p.name="+p.name);
11
12document.write(" ");
复制代码
运行结果：
那么Person类通过神马方式来继承Object类的呢，是使用原型(prototye)的方式继承的：
1/定义一个Person类/
2functionPerson(_name,_age){
3this.name=_name;
4this.age=_age;
5}
6Person.prototype=newObject();//让Person类继承Object类
由于JavaScript规定，任何类都继承自Object类，所以"Person.prototype=newObject();//让Person类继承Object类"即使我们不写，我猜想JavaScript引擎也会自动帮我们加上这句话，或者是使用"Person.prototype=Object.prototype;"这种方式，让Person类去继承Object类。"Person.prototype=newObject();"，其实这样就相当于Object对象是Person的一个原型，这样就相当于了把Object对象的属性和方法复制到了Person上了。
二、new运算符是如何工作的
我们先看看这样一段代码：
1varp=newPerson("孤傲苍狼",24);//创建一个人，名字是孤傲苍狼
很简单的一段代码，我们来看看这个new究竟做了什么？我们可以把new的过程拆分成以下三步：
1.varp={};初始化一个对象p。
2.p.__proto__=Person.prototype;，将对象p的__proto__属性设置为Person.prototype
3.Person.call(p,"孤傲苍狼",24);调用构造函数Person来初始化p。
关键在于第二步，我们来证明一下：
1varp=newPerson("孤傲苍狼",24);//创建一个人，名字是孤傲苍狼
2alert("p.__proto__===Person.prototype的结果是："+(p.__proto__===Person.prototype));
在火狐下的运行结果是：
这段代码会返回true。说明我们步骤2的正确。
注意：__proto__这个属性只有在firefox或者chrome浏览器中才是公开允许访问的，因此，其他基于IE内核的浏览器是不会返回true的。
那么__proto__是什么？在这里简单地说下。每个对象都会在其内部初始化一个属性，就是__proto__，当我们访问一个对象的属性时，如果这个对象内部不存在这个属性，那么他就会去__proto__里找这个属性，这个__proto__又会有自己的__proto__，于是就这样一直找下去，也就是我们平时所说的原型链的概念。
按照标准，__proto__是不对外公开的，也就是说是个私有属性，在IE下是无法访问__proto__属性的，但是Firefox的引擎将他暴露了出来成为了一个公有的属性，我们可以对外访问和设置。
好，概念说清了，让我们看一下下面这些代码：
复制代码
1
2varPerson=function(){};
3Person.prototype.Say=function(){
4alert("Personsay");
5}
6varp=newPerson();
7p.Say();
8
复制代码
这段代码很简单，我们看下为什么p可以访问Person的Say。
首先
1varp=newPerson()；
可以得出
1p.__proto__=Person.prototype
那么当我们调用p.Say()时，首先p中没有Say这个属性，于是，他就需要到他的__proto__中去找，也就是Person.prototype，而我们在上面定义了
1Person.prototype.Say=function(){
2alert("Personsay");
3};
于是，就找到了这个方法。
接下来，让我们看个更复杂的。
复制代码
1
2varPerson=function(){};
3Person.prototype.Say=function(){
4alert("Personsay");
5Person.prototype.Salarywritescode=50000;
6varProgrammerwww.wang027.com=function(){};
7Programmer.prototype=newPerson();//让程序员类从人这个类继承
8Programmer.prototype.WriteCode=function(){
9alert("programmerwritescode");
10};
11Programmer.prototype.Salary=500;
12varp=newProgrammer();
13p.Say();
14p.WriteCode();
15alert(p.Salary);
16
复制代码
我们来做这样的推导：
1varp=newProgrammer();
可以得出
1p.__proto__=Programmer.prototype;
而在上面我们指定了
1Programmer.prototype=newPerson();
我们来这样拆分，
1varp1=newPerson();
2Programmer.prototype=p1;
那么:
1p1.__proto__=Person.prototype;
2Programmer.prototype.__proto__=Person.prototype;
由根据上面得到
1p.__proto__=Programmer.prototype
可以得到：
1p.__proto__.__proto__=Person.prototype
好，算清楚了之后我们来看上面的结果,p.Say()。由于p没有Say这个属性，于是去p.__proto__，也就是Programmer.prototype，也就是p1中去找，由于p1中也没有Say，那就去p.__proto__.__proto__，也就是Person.prototype中去找，于是就找到了Say方法。这也就是原型链的实现原理。
以下代码展示了JS引擎如何查找属性：
复制代码
1functiongetProperty(obj,prop){
2if(obj.hasOwnProperty(prop))
3returnobj[prop];
4elseif(obj.__proto__!==null)
5returngetProperty(obj.__proto__,prop);//递归
6else
7returnundefined;
8}
复制代码
范例：查找p对象的Say方法
复制代码
1
2/查找obj对象的prop属性/
3functiongetProperty(obj,prop){
4if(obj.hasOwnProperty(prop))
5returnobj[prop];
6elseif(obj.__proto__!==null)
7returngetProperty(obj.__proto__,prop);//递归
8else
9returnundefined;
10}
11
12varPerson=function(){};//定义Person类
13Person.prototype.Say=function(){
14alert("Personsay");
15}
16Person.prototype.Salary=50000;
17
18varProgrammer=function(){};//定义Programmer类
19//Programmer.prototype=newPerson();//让程序员类从人这个类继承，写法一
20Programmer.prototype=Person.prototype;//让程序员类从人这个类继承，写法二
21Programmer.prototype.WriteCode=function(){
22alert("programmerwritescode");
23};
24Programmer.prototype.Salary=500;
25varp=newProgrammer();
26varSayFn=getProperty(p,"Say");//查找p对象的Say方法
27SayFn.call(p);//调用找到的Say方法
28
|
