Javascript 类：如何在父类代码中访问被覆盖的父类函数

Question

Javascript ES6（节点 8.4.0 和最新的 chrome 和最新的 Firefox）

我期待

class Parent {
    init(){
        console.log("Parent init") ;
        this._surname = "McClass" ;
    }
    constructor() {
        console.log("Parent constructor") ;
        this.init();
    }

    get surname(){
        return this._surname ;
    }
}

class Child extends Parent {

    init(){
        console.log("Child init") ;
    }
    constructor() {
        super();
        console.log("Child constructor") ;
        this.init();
    }    
}

var child = new Child() ;

console.log(child.surname);

给出以下输出；

Parent constructor
Parent init
Child constructor
Child init
McClass

（这是可比较的 C++ 代码给出的）

唉，我明白了；

Parent constructor
Child init
Child constructor
Child init
undefined

我是不是做错了什么，或者这是正确的预期行为，如果是这样，如何证明是合理的？

编辑；

请参阅下面的 MinusFour 回答，了解如何实现我正在尝试做/期望的事情。

至于为什么观察到的输出是“正确”的行为和合理的；

正如 Bergi 指出的（在 cmets 中），js 中对对象方法的所有调用实际上都是“虚拟的”（添加到对象原型继承链中的该名称的最后一个方法是第一个找到并因此执行的）。事实证明，调用在类构造上下文中仍然有效。

C++ 在构造过程中不应用虚方法行为，但 Java 再次应用，并且您在可比较的 Java 代码中获得相同的输出（如上），因此观察到的行为有先例。

Answer 1

你可以这样做：

Parent.prototype.init.call(this);

class Parent {
  init() {
    console.log("Parent init");
    this._surname = "McClass";
  }
  constructor() {
    console.log("Parent constructor");
    Parent.prototype.init.call(this);
  }

  get surname() {
    return this._surname;
  }
}

class Child extends Parent {

  init() {
    console.log("Child init");
  }
  constructor() {
    super();
    console.log("Child constructor");
    this.init();
  }
}

var child = new Child();

为了确保它永远不会被覆盖，但我建议你一开始就不要覆盖它。

Answer 2

这是预期的行为，因为它可以在遵循规范的既定 ES6 类实现中看到。

this指的是当前类实例，在Child被实例化的情况下是Child的一个实例——即使在Parent类中，因为只有一个实例，它是instanceof Child .

如果Child 覆盖该方法，则它有责任提供调用它的机制。考虑到 init 遵循一些记录在案的约定，并且是发生类初始化以使构造函数更精简和更可测试的地方，它是：

class Parent {
    init(){...}
    constructor() {
        this.init();
    }
    ...
}

...

class Child extends Parent {
    init(){
        super.init();
        ...
    }
    // optional, as long as `init` contains all init logic
    constructor() {
        super();
    }    
}

产生一个序列：

Parent constructor
Parent init
Child init
Child constructor

如果init 应该在两个类中完全独立工作，则不应覆盖它。方法的名称应该不同，例如initParent 和initChild。或者可以使用任何其他方式来避免命名冲突，例如：

const init = Symbol('Parent init');
class Parent {
    [init](){...}
    constructor() {
        this[init]();
    }
    ...
}

...

const init = Symbol('Child init');
class Child extends Parent {
    [init](){...}
    constructor() {
        this[init](); // totally independent method
    }
}