Apa cara standar untuk memanggil metode statis? Saya bisa memikirkan menggunakan constructoratau menggunakan nama kelas itu sendiri, saya tidak suka yang terakhir karena merasa tidak perlu. Apakah yang pertama direkomendasikan, atau ada yang lain?

Berikut ini contoh (buat-buat):

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

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

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

Kedua cara itu layak, tetapi mereka melakukan hal-hal yang berbeda ketika menyangkut pewarisan dengan metode statis yang ditimpa. Pilih orang yang perilakunya Anda harapkan:

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

Mengacu pada properti statis melalui kelas akan benar-benar statis dan terus-menerus memberikan nilai yang sama. Menggunakan this.constructorsebaliknya akan menggunakan pengiriman dinamis dan merujuk ke kelas instance saat ini, di mana properti statis mungkin memiliki nilai yang diwarisi tetapi juga bisa diganti.

Ini cocok dengan perilaku Python, di mana Anda dapat memilih untuk merujuk ke properti statis baik melalui nama kelas atau instance self.

Jika Anda mengharapkan properti statis tidak akan ditimpa (dan selalu merujuk ke salah satu dari kelas saat ini), seperti di Jawa , gunakan referensi eksplisit.

Saya menemukan thread ini mencari jawaban untuk kasus yang sama. Pada dasarnya semua jawaban ditemukan, tetapi masih sulit untuk mengekstrak esensi dari mereka.

Jenis Akses

Asumsikan kelas Foo mungkin berasal dari beberapa kelas lain dengan esensi lebih banyak dari kelas itu.

Kemudian mengakses

• dari metode statis / pengambil Foo
  • beberapa metode / pengambil statis yang mungkin ditimpa :
    • this.method()
    • this.property
  • beberapa metode instance / pengambil yang mungkin ditimpa :
    • tidak mungkin dengan desain
  • memiliki metode / pengambil statis non-override :
    • Foo.method()
    • Foo.property
  • memiliki metode instance / pengambil non-override :
    • tidak mungkin dengan desain
• dari metode instance / pengambil Foo
  • beberapa metode / pengambil statis yang mungkin ditimpa :
    • this.constructor.method()
    • this.constructor.property
  • beberapa metode instance / pengambil yang mungkin ditimpa :
    • this.method()
    • this.property
  • memiliki metode / pengambil statis non-override :
    • Foo.method()
    • Foo.property
  • memiliki metode instance / pengambil non-override :
    • tidak mungkin dengan niat kecuali menggunakan beberapa solusi :
      • Foo.prototype.method.call( this )
      • Object.getOwnPropertyDescriptor( Foo.prototype,"property" ).get.call(this);

Perlu diingat bahwa menggunakan thistidak berfungsi seperti ini saat menggunakan fungsi panah atau memanggil metode / getter secara eksplisit terikat dengan nilai kustom.

Latar Belakang

• Ketika dalam konteks metode instance atau pengambil
  • this mengacu pada contoh saat ini.
  • super pada dasarnya mengacu pada contoh yang sama, tetapi sedikit menangani metode dan getter yang ditulis dalam konteks beberapa kelas saat ini sedang diperluas (dengan menggunakan prototipe prototipe Foo).
  • definisi kelas instance yang digunakan untuk membuatnya tersedia per this.constructor.
• Ketika dalam konteks metode statis atau pengambil tidak ada "instance saat ini" dengan niat dan sebagainya
  • this tersedia untuk merujuk langsung ke definisi kelas saat ini.
  • super juga tidak merujuk pada beberapa instance, tetapi pada metode statis dan getter yang ditulis dalam konteks beberapa kelas saat ini sedang diperluas.

Kesimpulan

Coba kode ini:

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

Jika Anda berencana melakukan warisan apa pun, maka saya akan merekomendasikan this.constructor. Contoh sederhana ini harus menggambarkan mengapa:

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()akan masuk ConstructorSuper Hello ConstructorSuper!ke konsol
• test2.callPrint()akan masuk ConstructorSub Hello ConstructorSub!ke konsol

Kelas bernama tidak akan berurusan dengan warisan dengan baik kecuali jika Anda secara eksplisit mendefinisikan kembali setiap fungsi yang membuat referensi ke Kelas bernama. Berikut ini sebuah contoh:

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()akan masuk NamedSuper Hello NamedSuper!ke konsol
• test4.callPrint()akan masuk NamedSuper Hello NamedSub!ke konsol

Lihat semua yang di atas berjalan di Babel REPL .

Anda dapat melihat dari ini yang test4masih berpikir itu di kelas super; dalam contoh ini mungkin tidak tampak seperti masalah besar, tetapi jika Anda mencoba untuk mereferensikan fungsi anggota yang telah ditimpa atau variabel anggota baru, Anda akan menemukan diri Anda dalam masalah.