各种访问

Question

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

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

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

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

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

Answer 1

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

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.constructor代替将使用动态分派并引用当前实例的类，其中静态属性可能具有继承的值但也可以被覆盖。

这符合Python的行为，您可以选择通过类名或实例self来引用静态属性。

如果您希望不覆盖静态属性（并且始终引用当前类的静态属性）like in Java，请使用显式引用。

Answer 2

我偶然发现了这个线程，寻找类似案例的答案。基本上所有答案都已找到，但仍难以从中提取必需品。

各种访问

假设一个类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);

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

背景

在实例的方法或getter的上下文中

this指的是当前实例。

super基本上是指同一个实例，但是在某些类当前类的上下文中编写的有些寻址方法和getter正在扩展（通过使用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 );

Answer 3

如果您计划进行任何类型的继承，那么我建议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!记录到控制台

See all the above running in Babel REPL

你可以从中看到test4仍然认为它属于超级班级;在这个例子中，它可能看起来不是什么大不了的事，但如果你试图引用已被覆盖的成员函数或新的成员变量，你将发现自己陷入困境。

从常规ES6类方法中调用静态方法

3 个答案:

各种访问

背景

结论