如何在es6 javascript类中获取父函数？

Question

If I have something like

class A {
    constructor() {
        this.test = function(){return 1;};
    }
}

class B extends A {
    constructor() {
        super(); 
        this.test = function(){alert(  super.test()   );};
    }
}

This does not work, but is there a way I can access the parent function test()?

Answer 1

This does not work, but is there a way I can access the parent function test()?

Because you're not using the prototype for the base class method, you can't use super.test() to reference it. Instead, this.test is just a property of your current object. If there's some reason you don't want to use the prototype for methods, you could do this:

class A {
    constructor() {
        this.test = function(){return 1;};
    }
}

class B extends A {
    constructor() {
        super();
        let priorTest = this.test; 
        this.test = function(){alert(  priorTest.call(this)   );};
    }
}

To further explain, there's only one this.test property so when you assign this.test = ... in class B, you overwrite the previous this.test so you can't then refer to it in the implementation. But, you can save its value before you overwrite it and then use that.

Also, some people mistakenly think that this refers to a different object inside a base class method vs. a derived class method. That is not the case. There's only one object and both the base class and derived class have methods on that object. So, this.test = xxx in the base class refers to the exact same property as this.test = yyy in the derived class. Methods defined on the prototype are actually saved on separate objects though so they can all exist independently. When you reference this.test and there is no "own" property directly on the current object, then Javascript will search the prototype chain to see if it finds a property in the prototype chain with the desired name. If it does, then it will return/execute that one.

---

The ES6 way to do this is to use the ES6 syntax for defining methods which will use the prototype and then you can use super.test() to refer to the base class implementation because in the prototype chain each class gets its own object on which to define methods that are searched if there is no "own" property with the specified name.

class A {
    constructor() {
    }
    test() {
        return 1;
    }
}

class B extends A {
    constructor() {
        super(); 
    }
    test() {
        alert(super.test());
    }
}