202

调用静态方法的标准方法是什么？我可以考虑使用constructor或使用类本身的名称，我不喜欢后者，因为它觉得没有必要。前者是推荐的方式，还是有其他方式？

这是一个（人为的）示例：

class SomeObject {
  constructor(n){
    this.n = n;
  }

  static print(n){
    console.log(n);
  }

  printN(){
    this.constructor.print(this.n);
  }
}
4

3 回答 3

235

这两种方式都是可行的，但是当涉及到使用重写的静态方法进行继承时，它们会做不同的事情。选择您期望的行为：

class Super {
  static whoami() {
    return "Super";
  }
  lognameA() {
    console.log(Super.whoami());
  }
  lognameB() {
    console.log(this.constructor.whoami());
  }
}
class Sub extends Super {
  static whoami() {
    return "Sub";
  }
}
new Sub().lognameA(); // Super
new Sub().lognameB(); // Sub

通过类引用静态属性实际上是静态的，并且不断给出相同的值。使用this.constructorinstead 将使用动态调度并引用当前实例的类，其中静态属性可能具有继承的值，但也可能被覆盖。

这与 Python 的行为相匹配，您可以选择通过类名或实例引用静态属性self。

如果您希望静态属性不会被覆盖（并且始终引用当前类之一），例如在 Java 中，请使用显式引用。

于 2015-02-21T16:39:46.913 回答
80

我偶然发现了这个线程来寻找类似案例的答案。基本上所有的答案都找到了，但仍然很难从中提取要领。

访问类型

假设一个类 Foo 可能派生自其他一些类，并且可能有更多类派生自它。

然后访问

  • 来自 Foo 的静态方法/getter
    • 一些可能被覆盖的静态方法/getter：
      • this.method()
      • this.property
    • 一些可能被覆盖的实例方法/getter：
      • 设计不可能
    • 自己的非覆盖静态方法/getter：
      • Foo.method()
      • Foo.property
    • 自己的非覆盖实例方法/getter：
      • 设计不可能
  • 来自 Foo 的实例方法/getter
    • 一些可能被覆盖的静态方法/getter：
      • this.constructor.method()
      • this.constructor.property
    • 一些可能被覆盖的实例方法/getter：
      • this.method()
      • this.property
    • 自己的非覆盖静态方法/getter：
      • Foo.method()
      • Foo.property
    • 自己的非覆盖实例方法/getter：
      • 除非使用一些解决方法，否则不可能有意：
        • Foo.prototype.method.call( this )
        • Object.getOwnPropertyDescriptor( Foo.prototype,"property" ).get.call(this);

请记住，this在使用箭头函数或调用明确绑定到自定义值的方法/getter 时，使用不会以这种方式工作。

背景

  • 在实例的方法或 getter 的上下文中
    • this指的是当前实例。
    • super基本上是指相同的实例，但在某些类当前正在扩展的上下文中编写的一些寻址方法和吸气剂（通过使用 Foo 原型的原型）。
    • 在创建实例时使用的实例类的定义是可用的this.constructor。
  • 当在静态方法或 getter 的上下文中没有意图的“当前实例”等
    • this可以直接引用当前类的定义。
    • super也不是指某个实例，而是指在当前正在扩展的某个类的上下文中编写的静态方法和 getter。

结论

试试这个代码：

class A {
  constructor( input ) {
    this.loose = this.constructor.getResult( input );
    this.tight = A.getResult( input );
    console.log( this.scaledProperty, Object.getOwnPropertyDescriptor( A.prototype, "scaledProperty" ).get.call( this ) );
  }

  get scaledProperty() {
    return parseInt( this.loose ) * 100;
  }
  
  static getResult( input ) {
    return input * this.scale;
  }
  
  static get scale() {
    return 2;
  }
}

class B extends A {
  constructor( input ) {
    super( input );
    this.tight = B.getResult( input ) + " (of B)";
  }
  
  get scaledProperty() {
    return parseInt( this.loose ) * 10000;
  }

  static get scale() {
    return 4;
  }
}

class C extends B {
  constructor( input ) {
    super( input );
  }
  
  static get scale() {
    return 5;
  }
}

class D extends C {
  constructor( input ) {
    super( input );
  }
  
  static getResult( input ) {
    return super.getResult( input ) + " (overridden)";
  }
  
  static get scale() {
    return 10;
  }
}


let instanceA = new A( 4 );
console.log( "A.loose", instanceA.loose );
console.log( "A.tight", instanceA.tight );

let instanceB = new B( 4 );
console.log( "B.loose", instanceB.loose );
console.log( "B.tight", instanceB.tight );

let instanceC = new C( 4 );
console.log( "C.loose", instanceC.loose );
console.log( "C.tight", instanceC.tight );

let instanceD = new D( 4 );
console.log( "D.loose", instanceD.loose );
console.log( "D.tight", instanceD.tight );

于 2017-04-29T10:11:59.387 回答
21

如果您打算进行任何类型的继承，那么我会推荐this.constructor. 这个简单的例子应该说明原因：

class ConstructorSuper {
  constructor(n){
    this.n = n;
  }

  static print(n){
    console.log(this.name, n);
  }

  callPrint(){
    this.constructor.print(this.n);
  }
}

class ConstructorSub extends ConstructorSuper {
  constructor(n){
    this.n = n;
  }
}

let test1 = new ConstructorSuper("Hello ConstructorSuper!");
console.log(test1.callPrint());

let test2 = new ConstructorSub("Hello ConstructorSub!");
console.log(test2.callPrint());
  • test1.callPrint()将登录ConstructorSuper Hello ConstructorSuper!到控制台
  • test2.callPrint()将登录ConstructorSub Hello ConstructorSub!到控制台

命名类不能很好地处理继承，除非您明确地重新定义每个引用命名类的函数。这是一个例子：

class NamedSuper {
  constructor(n){
    this.n = n;
  }

  static print(n){
    console.log(NamedSuper.name, n);
  }

  callPrint(){
    NamedSuper.print(this.n);
  }
}

class NamedSub extends NamedSuper {
  constructor(n){
    this.n = n;
  }
}

let test3 = new NamedSuper("Hello NamedSuper!");
console.log(test3.callPrint());

let test4 = new NamedSub("Hello NamedSub!");
console.log(test4.callPrint());
  • test3.callPrint()将登录NamedSuper Hello NamedSuper!到控制台
  • test4.callPrint()将登录NamedSuper Hello NamedSub!到控制台

查看以上所有在 Babel REPL 中运行的内容。

从这里可以看出，它test4仍然认为它在超类中；在这个例子中，它可能看起来没什么大不了的，但是如果你试图引用已经被覆盖的成员函数或新的成员变量，你会发现自己有麻烦了。

于 2015-02-20T17:36:45.100 回答