Оба способа жизнеспособны, но они делают разные вещи, когда дело доходит до наследования с переопределенным статическим методом. Выберите того, чье поведение вы ожидаете:

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.

Если вы ожидаете, что статические свойства не будут переопределены (и всегда будут ссылаться на один из текущего класса), как в Java, используйте явную ссылку.

Я наткнулся на эту ветку в поисках ответа на похожий случай. Практически все ответы найдены, но извлечь из них самое главное по-прежнему сложно.

Виды доступа

Предположим, что класс Foo, вероятно, является производным от какого-то другого класса (ов), и, возможно, от него производят больше классов.

Затем доступ

• from static method/getter of Foo
  • some probably overridden static method/getter:
    • this.method()
    • this.property
  • some probably overridden instance method/getter:
    • impossible by design
  • own non-overridden static method/getter:
    • Foo.method()
    • Foo.property
  • own non-overridden instance method/getter:
    • impossible by design
• from instance method/getter of Foo
  • some probably overridden static method/getter:
    • this.constructor.method()
    • this.constructor.property
  • some probably overridden instance method/getter:
    • this.method()
    • this.property
  • own non-overridden static method/getter:
    • Foo.method()
    • Foo.property
  • own non-overridden instance method/getter:
    • not possible by intention unless using some workaround:
      • Foo.prototype.method.call( this )
      • Object.getOwnPropertyDescriptor( Foo.prototype,"property" ).get.call(this);

Имейте в виду, что использование this не работает таким образом при использовании стрелочных функций или при вызове методов / методов получения, явно привязанных к настраиваемому значению.

Фон

• When in context of an instance's method or getter
  • this is referring to current instance.
  • super в основном относится к одному и тому же экземпляру, но в некоторой степени относится к методам и геттерам, написанным в контексте некоторого текущего класса, расширяемого (с использованием прототипа прототипа Foo).
  • определение класса экземпляра, используемого при его создании, доступно в this.constructor.
• When in context of a static method or getter there is no "current instance" by intention and so
  • this is available to refer to the definition of current class directly.
  • super тоже не относится к какому-то экземпляру, а к статическим методам и геттерам, написанным в контексте некоторого класса, который расширяется.

Заключение

Попробуйте этот код:

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 );

Если вы планируете какое-либо наследование, я бы порекомендовал 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 все еще думает, что это суперкласс; в этом примере это может показаться несущественным, но если вы пытаетесь ссылаться на функции-члены, которые были переопределены, или на новые переменные-члены, вы столкнетесь с проблемами.