再和“面向对象”谈恋爱 - 继续（五）

2023年10月31日 234次阅读 来源: kaivon

经由历程上一篇文章想必列位老铁已熟习了class了，这篇文章接着引见继续。面向对象里最大的特征应当就属继续了。一个项目能够须要不停的迭代、完美、晋级。那每一次的更新你是要从新写呢，照样在原有的基础上改吧改吧呢？固然，不是缺心眼的人一定都会在本来的基础上改吧改吧，那这个改吧改吧就须要用到继续了。

在第二篇文章里说过原型实例跟组织函数之间的继续，而且还讲了一道推算题。终究我们邃晓，实例为何能继续原型上的内容是因为prototype，所以在ES5内里想要继续的话就得经由历程原型，须要对prototype举行一顿践踏才行。那到了ES6内里一切就简单了，像开了挂似的！so easy，那里不会点那里！

继续

  • class类能够经由历程extends完成继续
  • 应用super关键字引入父类的组织函数
  • ES6划定子类必需在组织函数（constructor）里先挪用super要领
  • 子类能同时继续父类的同享要领与私有要领
//这个类做为父类('老王')
class OldWang{   
    constructor(work,money){
        this.work=work;
        this.money=money;
    }
    showWork(){
        console.log(`老王是个${this.work}，看了我的文章后，才达到了${this.level}，一个月能挣${this.money}元`);
    }
    static play(){    //这是个私有要领，但子类依旧能继续到
        console.log('大吉大利，今晚吃鸡！不会玩游戏的前端不是个好前端！');
    }
}

//子类继续父类
class SmallWang extends OldWang{   
    constructor(work,money,level){
        //这里必需先写super，不然会报错
        super(work,money,level);
        this.level=level;   //只要用了super，才运用this
    }
}

//天生实例
const wang=new SmallWang('前端',20000,'T5');
wang.showWork();    //老王是个前端，看了我的文章后，才达到了T5，一个月能挣20000元
SmallWang.play();    //大吉大利，今晚吃鸡！不会玩游戏的前端不是个好前端！  子类能继续父类的私有要领

//与ES5里的实例是一致的
console.log(
    Object.getPrototypeOf(SmallWang)===OldWang, //true 子类的原型是OldWang，也就是说，它是OldWang的实例
    wang instanceof OldWang,        //true
    wang instanceof SmallWang,        //true
);

ES5的继续，本质是先声明子类，然后经由历程call要领将父类的要领添加到子类上，而ES6的继续机制完整差别。本质是声清楚明了子类后，子类并没有this对象，而是应用super要领引入父类的this对象，再将this修正成子类，就这么奇异！

new.target

new是天生实例的敕令。ES6为new敕令引入了一个new.target属性，该属性平常用在组织函数当中

  • new.target返回new敕令作用于的谁人类
  • 子类继续父类时，new.target返回子类
class Person{
    constructor(){
        //如果类不是经由历程new挪用的，就会返回undefined
        if(new.target===undefined){
            throw new Error('请运用new天生实例！');
        }
        console.log(new.target.name);
    }
}
new Person();    //Person类(返回了new作用于的谁人类)
Person();        //有些浏览器能够不带new天生实例，就会抛出一个毛病

class Man extends Person{
}
new Man();    //Man（子类继续父类时，new.target会返回子类）


//应用这个特征完成一个不能自力运用，必需继续后才用的类（像React里的组件）
class Uncle{
    constructor(){
        if(new.target===Uncle){
            throw new Error('这个类不能实例化，只能继续后再用');
        }
    }
    showUncle(){
        console.log('都是他舅');
    }
}
//new Uncle();    报错

//经由历程继续就能够运用Uncle了
class BigUncle extends Uncle{
    constructor(){
        super();    //引入父类的组织函数，必需加不然报错
        this.uncle='他大舅';
    }
}

//实例
const uncle=new BigUncle();
uncle.showUncle();    //都是他舅

原型

class里的原型关联相对于ES5里的原型关联，ES6对其举行了修正，但只修正了子类与父类之间的关联，别的的关联并没有修正。

  1. 子类的__proto__，示意组织函数的继续，指向父类组织函数
  2. 子类prototype属性的__proto__，示意要领的继续，指向父类的prototype

ES5里的继续关联，在第二篇文章里细致引见过，再回忆一下：

//ES5的继续关联
const str=new String(123);
console.log(
    str.__proto__===String.prototype，       //true
    String.__proto__===Function.prototype   //true
);  

//能够看到不论实例照样组织函数，它们的__proto__属性永久都指向原型

ES6与ES5的对照以下：

//ES5
function Ball(){}
function Football(){
    Ball.call(this);    //ES5的继续
}

//ES6
class Father{};
class Son extends Father{}

//组织函数，关联没变
console.log(
    '组织函数',
    Ball.__proto__===Ball.prototype,    //false
    Father.__proto__===Father.prototype,//false
    
    Ball.__proto__===Function.prototype,    //true
    Father.__proto__===Function.prototype    //true
);

//实例，关联没变
console.log(
    '实例',
    new Ball().__proto__===Ball.prototype,        //true
    new Father().__proto__===Father.prototype    //true
);

//子类，关联变了
console.log(
    '子类的__proto__',
    Football.__proto__===Ball,    //false ES5
    Football.__proto__===Function.prototype,//true  ES5
    
    Son.__proto__===Father,     //true ES6
    Son.__proto__===Father.prototype,    //false ES6
    
    //ES6的变化为：子类的__proto__指向父类
);

console.log(
    '子类的prototype的__proto__属性',
    Football.prototype.__proto__===Ball.prototype,    //false ES5
    Football.prototype.__proto__===Object.prototype,//true  ESS
    
    Son.prototype.__proto__===Object.prototype,     //false ES6
    Son.prototype.__proto__===Father.prototype,     //true ES6
    
    //ES6的变化为：子类的prototype的__proto__属性指向父类的prototype
);

由此能够看出ES6只修正了子类跟父类间的原型关联，别的的不受影响。那至于ES6对这两条关联做了修正的缘由跟ES6的继续机制有关联，ES6内部的继续用的是Object.setPrototypeOf要领（ES6新增的要领，作用是把第一个参数的原型设置成第二个参数），以下为内部历程：

{
    class Father{};
    class Son{};
    
    //son的实例继续Father的实例，内部会实行下面的代码
    Object.setPrototypeOf(Son.prototype,Father.prototype);
    //等同于Son.prototype.__proto__=Father.prototype;所以得出效果：子类prototype属性的__proto__属性，示意要领的继续，指向父类的prototype属性
    
    //son继续Father的私有属性，内部会实行下面的代码
    Object.setPrototypeOf(Son,Father);
    //等同于Son.__proto__=Father;所以得出效果：子类的__proto__属性，示意组织函数的继续，指向父类
}

为何用了setPrototypeOf后，等价于把第一个参数的__proto__的值设置成第二个参数？是因为setPrototypeOf要领的内部是如许的：

//setPrototypeOf要领内部重要代码
Object.setPrototypeOf=function(obj,proto){
    obj.__proto__=proto;
    return obj;
}

下一篇文章引见super关键字

    原文作者：kaivon
    原文地址: https://segmentfault.com/a/1190000015906814
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞