摘要：借用構(gòu)造函數(shù)借助或使用構(gòu)造函數(shù)缺少函數(shù)復(fù)用原型鏈繼承使用指向?qū)ο笞宇悷o法給父類傳遞參數(shù)無法使用字面量添加新方法所有子類對象共享父類所有方法和屬性引用類型組合繼承借用構(gòu)造函數(shù)對實(shí)例屬性繼承對共享方法繼承會調(diào)用兩次父類構(gòu)造函數(shù)繼承

借用構(gòu)造函數(shù),借助call或apply,使用Superclass構(gòu)造函數(shù),缺少函數(shù)復(fù)用

function Superclass(name = "default") {
        this.name = name;
    }
    
    function Subclass(age = 22, name) {
        this.age = age;
        Superclass.call(this, name);
        this.say = function () {
            console.log(`this.name=${this.name}...this.age=${this.age}`);
        };
    }
    
    const test = new Subclass(23);
    test.say();
    console.log(`test instanceof Subclass`, test instanceof Subclass);
    console.log(`test instanceof Superclass`, test instanceof Superclass);
    console.log(test.__proto__.constructor);
    console.log(Subclass.prototype.constructor);

原型鏈繼承,使用prototype指向Superclass對象,子類無法給父類傳遞參數(shù),無法使用字面量添加新方法,所有子類對象共享父類所有方法和屬性(引用類型)

    function Superclass(name = "default") {
        this.name   = name;
        this.colors = ["r", "y"];
    }

    function Subclass(age = 22) {
        this.age = age;
        this.say = function () {
            console.log(`this.name=${this.name}...this.age=${this.age}`);
        };
    }

    Subclass.prototype             = new Superclass();
    Subclass.prototype.constructor = Subclass;

    const test  = new Subclass(23);
    const test1 = new Subclass(24);
    test.colors.push("b");
    console.log(test.colors);
    console.log(test1.colors);
    test.say();
    test1.say();
    console.log(`test instanceof Subclass`, test instanceof Subclass);
    console.log(`test instanceof Superclass`, test instanceof Superclass);
    console.log(test.__proto__.constructor);
    console.log(Subclass.prototype.constructor);

組合繼承,prototype+call/apply,借用構(gòu)造函數(shù)對實(shí)例屬性繼承,prototype對共享方法繼承,會調(diào)用兩次父類構(gòu)造函數(shù)

    function Superclass(name = "default") {
        this.name = name;
    }

    Superclass.prototype.say = function () {
        console.log(this.name);
    };

    function Subclass(age = 22, name) {
        this.age = age;
        Superclass.call(name);
    }

    Subclass.prototype             = new Superclass();
    Subclass.prototype.constructor = Subclass;

    const test = new Subclass(23);
    test.say();
    console.log(`test instanceof Subclass`, test instanceof Subclass);
    console.log(`test instanceof Superclass`, test instanceof Superclass);
    console.log(test.__proto__.constructor);
    console.log(Subclass.prototype.constructor);

ES6 Class繼承

    class Superclass {
        constructor(name = "default") {
            this.name = name;
        }
    }
    class Subclass extends Superclass {
        constructor(age = 22, name) {
            super(name);
            this.age = age;
        }

        say() {
            console.log(`this.name=${this.name}...this.age=${this.age}`);
        }
    }

    const test = new Subclass(23);
    test.say();
    console.log(`test instanceof Subclass`, test instanceof Subclass);
    console.log(`test instanceof Superclass`, test instanceof Superclass);
    console.log(test.__proto__.constructor);
    console.log(Subclass.prototype.constructor);

Node util.inherits;

    function Superclass(name = "default") {
        this.name = name;
    }

    function Subclass(age = 22, name) {
        this.age = 22;
        Superclass.call(this, name);

        this.say = function () {
            console.log(`this.name=${this.name}...this.age=${this.age}`);
        };

    }

    require("util").inherits(Subclass, Superclass);

    const test = new Subclass(23);
    test.say();
    console.log(`test instanceof Subclass`, test instanceof Subclass);
    console.log(`test instanceof Superclass`, test instanceof Superclass);
    console.log(test.__proto__.constructor);
    console.log(Subclass.prototype.constructor);