Який стандартний спосіб викликати статичні методи? Я можу подумати про використання constructorабо використання самого класу, мені не подобається останній, оскільки він не вважає за потрібне. Це колишній рекомендований спосіб, чи є щось інше?

Ось (надуманий) приклад:

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

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

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

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

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, ймовірно, походить від якогось іншого класу, і, ймовірно, більше класів, похідних від нього.

Тоді звернення

• від статичного методу / геттера Foo
  • деякі, мабуть, перекриті статичний метод / геттер:
    • this.method()
    • this.property
  • якийсь, мабуть, перекритий метод / getter:
    • неможлива конструкція
  • власний не перекритий статичний метод / геттер:
    • Foo.method()
    • Foo.property
  • власний метод / getter неперевершеного екземпляра :
    • неможлива конструкція
• з методу екземпляра / getter Foo
  • деякі, мабуть, перекриті статичний метод / геттер:
    • this.constructor.method()
    • this.constructor.property
  • якийсь, мабуть, перекритий метод / getter:
    • this.method()
    • this.property
  • власний не перекритий статичний метод / геттер:
    • Foo.method()
    • Foo.property
  • власний метод / getter неперевершеного екземпляра :
    • НЕ представляється можливим за наміром , якщо не використовувати будь - то обхідний шлях :
      • Foo.prototype.method.call( this )
      • Object.getOwnPropertyDescriptor( Foo.prototype,"property" ).get.call(this);

Майте на увазі, що використання thisне працює таким чином при використанні функцій стрілок або виклику методів / Getters, явно пов'язаних із спеціальним значенням.

Фон

• Коли в контексті методу або отримувача екземпляра
  • this посилається на поточний екземпляр.
  • super в основному посилається на той самий екземпляр, але дещо адресація методів та гетерів, написаних у контексті поточного класу, розширюється (використовуючи прототип прототипу Фоо).
  • визначення класу екземпляра, що використовується при його створенні, доступне в this.constructor.
• Коли в контексті статичного методу або геттера немає "поточного екземпляра" за наміром і так
  • this Доступно безпосередньо для визначення поточного класу.
  • 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все ще думає, що це в суперкласі; у цьому прикладі це може не здатися величезною угодою, але якщо ви намагаєтеся посилатись на функції учасників, які були переопрацьовані або нові змінні члена, ви опинитесь у біді.