继承模式 命名空间

function inherit(Target, Origin) {
    // F.prototype = Origin.prototype;

    // function F() {};
    // Target.prototype = new F();        完美模式
    Target.prototype = Origin.prototype;    //此方法会导致原型链中数据都改变因为两者指向同一个存储地址  所以你变我也变
}

Father.prototype.lastName = 'taotao';

function Father() {}

function Son() {}
inherit(Son, Father);          //继承也要发生在 new 之前
Son.prototype.name = 123;   // 更改原型链属性值必须要在new出构造函数对象之前有效
var father = new Father();
var son = new Son();
           

命名空间  了解

另外一种防止变量污染的方法   闭包实现  

模仿jq实现链式调用如下

1.传统形式 过多的继承了没用的属性

2.借用构造函数 不能继承借用构造函数的原型 每次构造函数都要多走一个函数

该种方式实现继承只是借用别人的函数实现自己的功能   必须要有new  不然call   this 无意义

3.共享原型 不能随便改动自己的原型

Father.prototype.lastName = 'taotao';
function Father() {}

function Son() {}

//封装继承函数
function inherit(target,origin) {
    target.prototype = origin.prototype;
}
inherit(Son,Father);
son.prototype.name = 123  ; //对于原型的处理必须要在new 出对象之前
var father = new Father();
var son = new Son();


//可以实现继承  但是由于二者原型共用一个地址  所以不可随意更改原型 否则会造成父级原型数据更改
           

4.圣杯模式   完美

//圣杯模式继承

Father.prototype.lastName = 'taotao';
function Father() {};

function Son() {};


function inherit(target,origin) {
    F.prototype = origin.prototype;
    function F() {};
    target.prototype = new F();
    target.prototype.constructor = target;
    target.prototype.uber = origin.prototype;
   }
inherit(Son,Father);
Son.prototype.sex = 666;
//注意原型是对函数而言故son为构造函数名

var father = new Father()
var son = new Son();
    

           

//闭包原理实现圣杯继承

var inherit = (function() {

    var F = function() {};
    return function(target,origin) {
    F.prototype = origin.prototype;
    //对于原型的改变要发生在new 之前  否则无效  同样 继承也是必须在两个函数创建对象之前
    target.prototype = new F();
    target.prototype.constructor = target;
    target.prototype.uber = origin.prototype;    
}
}())
           

利用闭包实现变量私有化

function Deng(name,wife){
    var perpare = 'xiaozhang';
    
    this.name = name;
    this.wife = wife;
    this.disvoce = function() {
        this.wife = perpare;
    }
    this.changePerpare = function(target) {
        perpare = target;
    }
    this.say = function() {
        console.log(perpare);
    }

}

var  deng = new Deng('deng','xiaoliu');


该函数存在的闭包原理 
首先存在内外函数嵌套  
其次 创建构造函数对象时   会隐式启动var this = {}     最后会隐式返回this对象
相当于将三个this函数保存到了外部 形成了闭包    故var  perpare 成了私有变量
一直为函数所携带