วิธีมาตรฐานในการเรียกใช้วิธีการคงที่คืออะไร ฉันสามารถคิดถึงการใช้constructorหรือใช้ชื่อของคลาสเองฉันไม่ชอบอันหลังเพราะมันไม่จำเป็น อดีตเป็นวิธีที่แนะนำหรือมีอย่างอื่นอีกหรือไม่

นี่คือตัวอย่าง (contrived):

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แทนจะใช้การจัดส่งแบบไดนามิกและอ้างอิงคลาสของอินสแตนซ์ปัจจุบันโดยที่คุณสมบัติสแตติกอาจมีค่าที่สืบทอดมา แต่อาจแทนที่ได้

selfนี้ตรงกับพฤติกรรมของงูใหญ่ที่คุณสามารถเลือกที่จะอ้างถึงคุณสมบัติคงที่ทั้งผ่านชื่อชั้นหรืออินสแตนซ์

หากคุณคาดว่าคุณสมบัติสแตติกจะไม่ถูกแทนที่ (และอ้างอิงถึงหนึ่งในคลาสปัจจุบัน) เช่นใน Javaให้ใช้การอ้างอิงที่ชัดเจน

ฉันสะดุดกับหัวข้อนี้เพื่อค้นหาคำตอบของกรณีที่คล้ายกัน โดยทั่วไปจะพบคำตอบทั้งหมด แต่ก็ยังยากที่จะดึงข้อมูลสำคัญจากพวกเขา

ชนิดของการเข้าถึง

สมมติว่าคลาส Foo อาจได้รับมาจากคลาสอื่น (es) ที่มีคลาสที่น่าจะมาจากคลาสนั้นมากกว่า

จากนั้นเข้าถึง

• จากวิธีการคงที่ / ทะเยอทะยานของ Foo
  • บางคนอาจจะแทนที่วิธีคงที่ / ทะเยอทะยาน:
    • this.method()
    • this.property
  • บางคนอาจจะแทนที่วิธีการ / ทะเยอทะยาน:
    • เป็นไปไม่ได้ด้วยการออกแบบ
  • วิธีการแบบคงที่ / แทนที่ตัวเองที่ไม่ได้ถูกแทนที่ :
    • Foo.method()
    • Foo.property
  • วิธี / getter อินสแตนซ์ที่ไม่ถูกแทนที่ของตัวเอง:
    • เป็นไปไม่ได้ด้วยการออกแบบ
• จากตัวอย่าง method / getter ของ Foo
  • บางคนอาจจะแทนที่วิธีคงที่ / ทะเยอทะยาน:
    • this.constructor.method()
    • this.constructor.property
  • บางคนอาจจะแทนที่วิธีการ / ทะเยอทะยาน:
    • 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 โดยทั่วไปหมายถึงอินสแตนซ์เดียวกัน แต่วิธีการที่อยู่ค่อนข้างและ getters เขียนในบริบทของบางคลาสปัจจุบันหนึ่งขยาย (โดยใช้ต้นแบบของต้นแบบของ Foo)
  • 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ยังคงคิดว่ามันอยู่ในระดับสูง ในตัวอย่างนี้อาจดูเหมือนไม่ได้เป็นเรื่องใหญ่ แต่ถ้าคุณพยายามอ้างอิงฟังก์ชั่นสมาชิกที่ถูกแทนที่หรือตัวแปรสมาชิกใหม่คุณจะพบว่าตัวเองมีปัญหา