Statik yöntemleri çağırmanın standart yolu nedir? constructorSınıfın adını kullanmayı veya kullanmayı düşünebilirim, gerekli hissetmediği için ikincisini sevmiyorum. İlki önerilen yol mu, yoksa başka bir şey var mı?

İşte (tutarlı) bir örnek:

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

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

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

Her iki yol da uygulanabilir, ancak kalıtım söz konusu olduğunda geçersiz kılınmış bir statik yöntemle farklı şeyler yaparlar. Davranışını beklediğinizi seçin:

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

Sınıf aracılığıyla statik özelliğe atıfta bulunmak aslında statik olacaktır ve sürekli olarak aynı değeri verecektir. Kullanımı this.constructordinamik sevkini kullanmak ve statik özelliği, geçerli örneğinde sınıfına, sevk edecektir yerine belki miras değere sahip değil, aynı zamanda geçersiz kılınan olabilir.

Bu, sınıf adı veya örnek üzerinden statik özelliklere başvurmayı seçebileceğiniz Python'un davranışıyla eşleşir self.

Java'da olduğu gibi statik özelliklerin geçersiz kılınmamasını (ve her zaman geçerli sınıftan birine başvurmasını) bekliyorsanız, açık başvuruyu kullanın.

Benzer konuya cevap arayan bu iş parçacığı üzerinde tökezledi. Temel olarak tüm cevaplar bulunur, ancak onlardan gerekli olanları çıkarmak hala zordur.

Erişim Türleri

Muhtemelen başka sınıflardan türetilen bir Foo sınıfından, muhtemelen daha fazla sınıftan türetilmiş olduğunu varsayalım.

Sonra erişim

• statik yöntemden / Foo'dan
  • muhtemelen geçersiz kılınmış statik yöntem / alıcı:
    • this.method()
    • this.property
  • muhtemelen geçersiz kılınan örnek yöntemi / alıcısı:
    • tasarım imkansız
  • kendi üzerine geçersiz kılınmamış statik yöntem / alıcı:
    • Foo.method()
    • Foo.property
  • kendi üzerine geçersiz kılınan örnek yöntemi / alıcısı:
    • tasarım imkansız
• Foo örnek yönteminden / alıcısından
  • muhtemelen geçersiz kılınmış statik yöntem / alıcı:
    • this.constructor.method()
    • this.constructor.property
  • muhtemelen geçersiz kılınan örnek yöntemi / alıcısı:
    • this.method()
    • this.property
  • kendi üzerine geçersiz kılınmamış statik yöntem / alıcı:
    • Foo.method()
    • Foo.property
  • kendi üzerine geçersiz kılınan örnek yöntemi / alıcısı:
    • bazı geçici çözümler kullanılmadıkça niyetle mümkün değildir :
      • Foo.prototype.method.call( this )
      • Object.getOwnPropertyDescriptor( Foo.prototype,"property" ).get.call(this);

thisOk işlevlerini kullanırken veya yöntemleri / alıcıları açıkça özel değere bağlıyken kullanmanın bu şekilde çalışmadığını unutmayın .

Arka fon

• Bir örneğin yöntemi veya alıcısı bağlamında
  • this mevcut örneğe atıfta bulunuyor.
  • super temelde aynı örneğe atıfta bulunmakta, ancak bir şekilde sınıf akımları bağlamında yazılan yöntemlere ve alıcılara değinmektedir (Foo'nun prototipinin prototipini kullanarak).
  • örneği oluştururken kullanılan sınıfın tanımına göre kullanılabilir this.constructor.
• Statik bir yöntem veya alıcı bağlamında, niyeti gereği "şu anki örnek" yoktur.
  • this geçerli sınıfın tanımını doğrudan ifade etmek için kullanılabilir.
  • super bazı örneklere atıfta bulunmamakla birlikte, bazı sınıf akımları bağlamında yazılan statik yöntemlere ve alıcılara da uzanmaktadır.

Sonuç

Bu kodu deneyin:

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

Herhangi bir miras yapmayı planlıyorsanız, tavsiye ederim this.constructor. Bu basit örnek, nedenini göstermelidir:

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!konsola giriş yapacak
• test2.callPrint()ConstructorSub Hello ConstructorSub!konsola giriş yapacak

Adlandırılmış Sınıfa başvuru yapan her işlevi açıkça yeniden tanımlamazsanız, adlandırılmış sınıf kalıtımla güzelce ilgilenmez. İşte bir örnek:

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!konsola giriş yapacak
• test4.callPrint()NamedSuper Hello NamedSub!konsola giriş yapacak

Yukarıdakilerin tümünü Babel REPL'de bulabilirsiniz .

Bundan test4hala süper sınıfta olduğunu düşünen görebilirsiniz ; bu örnekte büyük bir anlaşma gibi görünmeyebilir, ancak geçersiz kılınan üye işlevlerine veya yeni üye değişkenlere başvurmaya çalışıyorsanız, kendinizi belada bulacaksınız.