采有闭包、原型链实现Js的真正继承和封装

 

Javascript对象创建过程：

1.初始化对象

2.将对象的__proto__=类的prototype属性

3.用类构造对象

 

__proto__：为原型链

 

每个对象都会在其内部初始化一个属性，就是__proto__，当我们访问一个对象的属性时，如果这个对象内部不存在这个属性，那么他就会去__proto__里找这个属性，这个__proto__又会有自己的__proto__，于是就这样一直找下去，也就是我们平时所说的原型链的概念。

 

2.将对象的__proto__　=　类的prototype属性，且prototype是一个对象。

 

因此为了实现继承，我们只要将对象的的原型链进行修改即可。

由于__proto__在对象创建后才可出现，其实这个属性也不能直接访问（原则上），但我们在类定义时就得确认类的继承关系。此时，我们突然发现以上加粗的公式。

类的prototype = 对象的 __proto__。好吧，现在只要在类的prototype上做文章即可。

 

可以想象，如果要加入父类的原型链，只有两种方法：

1.将子类的prototype=父类的prototype。这个非常不好，因为既然相等了，此时改变任何一个类的prototype，都会影响另一个类的prototype

2.将子类的prototype=父类的对象。这个是一个不错的想法，修改了类属性时，只是修改父类对象的一个实例，并不会修改父类的类。

然到就这样结束，不会的。为什么不会呢？因为我们在定义类时，并不想让类分配内存，我这类也许只是定义，未必会用，那么以上定义方式就悲剧了，子类的prototype=父类的对象（定义时就创建了父类的对象）。当然创建对象是必须的，可是我们是否可以创建一个不用分配内存（或很少内存）的对象呢，是的，你猜到了，定义一个什么都没有类，比如 var F = function(){};  new F(); 

好了，现在有空对象了，将子类的prototype=new F(); 纳尼？子类只是加入了F的原型链。好吧，我承认我有引导错误的行为，以上的第一种方法（将子类的prototype=父类的prototype）并不是不好，而是要看时机，因为我们害怕它们会相互绑定。但是时机来了，F类，我们并不会修改它任何属性（是的，它只是一个用来做空对象了，谁改了我和谁急）。Year,我们很巧妙的将F.prototype=父类的prototype

 

以上说的太认真了，好吧，其实就是那么简单：

 

var C = function(){}
var P = function(){}
var F = function(){}

C.prototype = new F();
F.prototype = P.prototype;

 以上只是完成了继承的大部分。其实由于类的构造函数被绑在类的prototype上，即prototype.constructor方法。好了，我们既然很粗鲁将子类的prototype移情，好在事情还没发展到需要分手的地步，

我们将子类的prototype.constructor=子类，即 

 

C.prototype.constructor = C;

 好了，既养了小三，又不失原配。我的GOD,i love javascript！

 

继承完成了，来谈一下闭包吧

 

 

(function(){

})();

 有此方法可以保护局部函数和局部变量，产生类的private效果。

 

可以把一个外部对象在期间进行封装，封装过程产生的局部函数和局部变量不会被外部访问。

 

var Js3={};  
  
(function(){  
          
        var ua = navigator.userAgent.toLowerCase(),  
        check = function(r) {  
            return r.test(ua);  
        },  
       isChrome = check(/\bchrome\b/);  
  
  
       Js3.isChrome = isChrome;  
  
}(); 

 

 其中的ua，isChrome变量,check函数只是局部的。

 

有了以上的概念，我们即可实现“采有闭包、原型链实现Js的真正继承和封装”。

 

 

Js3.apply = function(o, c) {
    if (o && c && typeof c == 'object') {
        for (var p in c) {
            o[p] = c[p];
        }
    }
    return o;
};
Js3.override = function(origclass, overrides) {
    if (overrides) {
        var p = origclass.prototype;
        Js3.apply(p, overrides);
        if (Js3.isIE && overrides.hasOwnProperty('toString')) {
            p.toString = overrides.toString;
        }
    }
};

Js5.extend = function() {
    var oc = Object.prototype.constructor;
    return function(sb, sp, overrides) {
        var coverrides = overrides;
        if (!overrides) {
            coverrides = sp;
            sp = sb;
        }

        var F = function() {
        }, sbp, spp = sp.prototype;
        F.prototype = spp;

        coverrides = coverrides(spp); 　//闭包调用

        if (!overrides) {
            sb = coverrides.constructor != oc ? coverrides.constructor : function() {
                sp.apply(this, arguments);
            };
        }
        sbp = sb.prototype = new F();
        sbp.constructor = sb;

        if (spp.constructor == oc) {
            spp.constructor = sp;
        }

        Js3.override(sb, coverrides);

        return sb;
    };
}();

 

应用如下：

var PClass = function() {
};
var Class = function() {
};
Js5.extend(Class, PClass, function(_super) { 
　//_super = super class，此函数将成为闭包，并被Js5.extend调用。
    var _prv = { // private:

    };
    return {  // public:

    };
});

 

注：类定义中的_prv等变量为静态变量，所有类的实例对象将共享变量。