javascript实现继承

深藏阁楼爱情的钟 2022-03-18 14:56 196阅读 0赞

//约定:下面将展开一个有点长的故事，所以有必要提前约定共同语言：
    /* * 约定 */
    function Fun(){ 
        // 私有属性
        var val = 1;        // 私有基本属性
        var arr = [1];      // 私有引用属性
        function fun(){ }    // 私有函数（引用属性）
    
        // 实例属性
        this.val = 1;               // 实例基本属性
        this.arr = [1];             // 实例引用属性
        this.fun = function(){ };    // 实例函数（引用属性）
    }
    
    // 原型属性
    Fun.prototype.val = 1;              // 原型基本属性
    Fun.prototype.arr = [1];            // 原型引用属性
    Fun.prototype.fun = function(){ };   // 原型函数（引用属性）
    
    console.log("--------------------");
    
    /** * 一.简单原型链 * * 3.优缺点 优点： 简单，易于实现 缺点： 修改sub1.arr后sub2.arr也变了，因为来自原型对象的引用属性是所有实例共享的。 可以这样理解：执行sub1.arr.push(2);先对sub1进行属性查找，找遍了实例属性（在本例中没有实例属性），没找到，就开始顺着原型链向上找，拿到了sub1的原型对象，一搜身，发现有arr属性。于是给arr末尾插入了2，所以sub2.arr也变了 创建子类实例时，无法向父类构造函数传参 */
    function Super(){ 
        this.val = 1;
        this.arr = [1];
    }
    function Sub(){ 
        // ...
    }
    Sub.prototype = new Super();    // 核心:拿父类实例来充当子类原型对象
    
    var sub1 = new Sub();
    var sub2 = new Sub();
    sub1.val = 2;
    sub1.arr.push(2);
    console.log(sub1.val);    // 2
    console.log(sub2.val);    // 1
    
    console.log(sub1.arr);    // 1, 2
    console.log(sub2.arr);    // 1, 2
    console.log(Sub.constructor, Sub.prototype.constructor); //[Function: Function] [Function: Super]
    
    console.log("--------------------");
    
    /** * 二.借用构造函数 * * 3.优缺点 优点： 解决了子类实例共享父类引用属性的问题 创建子类实例时，可以向父类构造函数传参 P.S.前辈就这么高效，两个缺陷瞬间修复 缺点： 无法实现函数复用，每个子类实例都持有一个新的fun函数，太多了就会影响性能，内存爆炸。。 P.S.好吧，刚修复了共享引用属性的问题，又出现了这个新问题。。 * */
    function Super(val){ 
        this.val = val;
        this.arr = [1];
    
        this.fun = function(){ 
            // ...
        }
    }
    function Sub(val){ 
        Super.call(this, val);   // 核心:借父类的构造函数来增强子类实例，等于是把父类的实例属性复制了一份给子类实例装上了（完全没有用到原型）
        // ...
    }
    
    var sub1 = new Sub(1);
    var sub2 = new Sub(2);
    sub1.arr.push(2);
    console.log(sub1.val);    // 1
    console.log(sub2.val);    // 2
    
    console.log(sub1.arr);    // 1, 2
    console.log(sub2.arr);    // 1
    
    console.log(sub1.fun === sub2.fun);   // false
    
    console.log("--------------------");
    
    /** * 三.组合继承（最常用） * *3.优缺点 优点： 不存在引用属性共享问题 可传参 函数可复用 缺点: （一点小瑕疵）子类原型上有一份多余的父类实例属性，因为父类构造函数被调用了两次，生成了两份，而子类实例上的那一份屏蔽了子类原型上的。。。又是内存浪费，比刚才情况好点，不过确实是瑕疵 */
    function Super(){ 
        // 只在此处声明基本属性和引用属性
        this.val = 1;
        this.arr = [1];
    }
    // 在此处声明函数
    Super.prototype.fun1 = function(){ };
    Super.prototype.fun2 = function(){ };
    //Super.prototype.fun3...
    function Sub(){ 
        Super.call(this);   // 核心
        // ...
    }
    Sub.prototype = new Super();    // 核心
    
    var sub1 = new Sub(1);
    var sub2 = new Sub(2);
    console.log(sub1.fun === sub2.fun);   // true
    console.log(Sub.prototype.constructor); //[Function: Super]
    
    console.log("--------------------");
    
    /** * 四.寄生组合继承（最佳方式） * * 3.优缺点 优点：完美了 缺点：理论上没有了（如果用起来麻烦不算缺点的话。。） P.S.用起来麻烦是一方面，另一方面是因为寄生组合式继承出现的比较晚，是21世纪初的东西，大家等不起这么久，所以组合继承是最常用的，而这个理论上完美的方案却只是课本上的最佳方式了 */
    function beget(obj){    // 生孩子函数 beget：龙beget龙，凤beget凤。
        var F = function(){ };
        F.prototype = obj;
        return new F();
    }
    function Super(){ 
        // 只在此处声明基本属性和引用属性
        this.val = 1;
        this.arr = [1];
    }
    // 在此处声明函数
    Super.prototype.fun1 = function(){ };
    Super.prototype.fun2 = function(){ };
    //Super.prototype.fun3...
    function Sub(){ 
        Super.call(this);   // 核心
        // ...
    }
    var proto = beget(Super.prototype); // 核心:切掉了原型对象上多余的那份父类实例属性
    proto.constructor = Sub;            // 核心
    Sub.prototype = proto;              // 核心
    
    var sub = new Sub();
    console.log(sub.val);
    console.log(sub.arr);
    console.log("--------------------");