Question

我正在使用ES6类，我的类（A）扩展了B类，B类扩展了C类。如何扩展方法，然后调用该方法的C版本。

class C {
  constructor() {
    console.log('class c');
  }
}

class B extends C {
  constructor() {
    super()
    console.log('no, I don't want this constructor.');
  }
}

class A extends B {
  constructor() {
    // What should I be doing here?  I want to call C's constructor.
    super.super();
  }
}

编辑：谢谢大家，我会停止尝试做这个愚蠢的事情。在我的情况下，代码重用的微小收益不值得杂技。

Answer 1

You can’t not call the parent’s constructor in an ES6 class.根据你的评论判断，也许你应该尝试这样的事情？

class Mixin {
  static include(constructor) {
    const descriptors = Object.getOwnPropertyDescriptors(Mixin.prototype);

    Object.keys(descriptors).forEach(name => {
      Object.defineProperty(constructor.prototype, name, descriptors[name]);
    });
  }

  someCommonFunction() {
    // Perform operation common to B and C
  }
}

delete Mixin.prototype.constructor;

class B extends A {
}

Mixin.include(B);

class C extends A {
}

Mixin.include(C);

Answer 2

简单但丑陋的方法是在A的构造函数中检查实例B：

class B extends C {
  constructor() {
    super()
    if (!(this instanceof A)) {
      console.log('no, no no, I don\'t want this!');  
    }
  }
}

＆＃13;

class A {
  constructor() {
    console.log('class c');
  }
}

class B extends A {
  constructor() {
    super()
    if (!(this instanceof C)) {
      console.log('no, no no, I don\'t want this!');  
    }
  }
}

class C extends B {
  constructor() {
    super();
  }
}

const c = new C()

＆＃13;

Answer 3

我能想到的最佳方式，可能不一定是最好的方式，是在B中定义一个调用A super()的函数，这样你就可以在C中继承它扩展，你会准备好它。

Answer 4

class C {
  constructor(){
    console.log('C');
  }
}

class AB extends C {
  constructor(){
    super();
  }
}

class B extexts AB {
  constructor(){
    super();
    console.log('B');
  }
}

class A extends AB {
  constructor(){
    super();
  }
}

我认为在两者之间构建一个类并从中扩展A和B是唯一的方法，因为evere构造函数必须首先调用他自己的超级构造函数。

new B(); // output is CB
new A(); // output is C

Answer 5

你需要一些杂技，我认为我不会建议这种形式是“干净/透明的代码”观点，但是可以按照以下方式进行：

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">

<script type="text/javascript">

class C {
  constructor() {
      this.fooExtension = null;
  }

  initC(aFoo) {
    this.fooExtension = aFoo;
  }

  foo() {
    if (this.fooExtension === null) {
        console.log('fooFromC');
    } else {
        console.log('extend foo called from C');
        this.fooExtension();
    }
  }
}

class B extends C {
  constructor() {
    super();
  }

  foo() {
    super.foo();
  }
}

class A extends B {
  constructor() {
    super();

    let fooExtension = function() {
      console.log('fooFromA');
    };

    this.initC(fooExtension);
  }
}

c = new C();
c.foo();

a = new A();
a.foo();

</script>
</head>
<body>
</body>
</html>

这将产生以下输出：

fooFromC
  扩展foo来自C
  fooFromA

如何在ES6中调用我的类'父级的父级构造函数？

5 个答案: