Cách tiêu chuẩn để gọi các phương thức tĩnh là gì? Tôi có thể nghĩ đến việc sử dụng constructorhoặc sử dụng tên của chính lớp đó, tôi không thích cái thứ hai vì nó không cảm thấy cần thiết. Đây có phải là cách được đề xuất, hoặc có cái gì khác không?

Đây là một ví dụ (giả định):

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

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

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

Cả hai cách đều khả thi, nhưng chúng làm những việc khác nhau khi nói đến kế thừa với một phương thức tĩnh được ghi đè. Chọn một hành vi mà bạn mong đợi:

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

Tham chiếu đến thuộc tính tĩnh thông qua lớp sẽ thực sự tĩnh và liên tục đưa ra cùng một giá trị. Sử dụng this.constructorthay thế sẽ sử dụng công văn động và tham chiếu đến lớp của cá thể hiện tại, trong đó thuộc tính tĩnh có thể có giá trị được kế thừa nhưng cũng có thể bị ghi đè.

Điều này phù hợp với hành vi của Python, nơi bạn có thể chọn tham chiếu đến các thuộc tính tĩnh thông qua tên lớp hoặc thể hiện self.

Nếu bạn mong muốn các thuộc tính tĩnh không bị ghi đè (và luôn tham chiếu đến một trong các lớp hiện tại), như trong Java , hãy sử dụng tham chiếu rõ ràng.

Tôi tình cờ tìm thấy chủ đề này để tìm câu trả lời cho trường hợp tương tự. Về cơ bản tất cả các câu trả lời được tìm thấy, nhưng vẫn khó để trích xuất các yếu tố cần thiết từ chúng.

Các loại quyền truy cập

Giả sử một lớp Foo có thể xuất phát từ một số lớp khác với nhiều lớp có lẽ bắt nguồn từ nó.

Sau đó truy cập

• từ phương thức tĩnh / getter của Foo
  • một số có thể ghi đè phương thức tĩnh / getter:
    • this.method()
    • this.property
  • một số phương thức / getter có thể bị ghi đè :
    • không thể bởi thiết kế
  • riêng tĩnh không ghi đè phương pháp / getter:
    • Foo.method()
    • Foo.property
  • riêng trường hợp không ghi đè phương pháp / getter:
    • không thể bởi thiết kế
• từ phương thức cá thể / getter của Foo
  • một số có thể ghi đè phương thức tĩnh / getter:
    • this.constructor.method()
    • this.constructor.property
  • một số phương thức / getter có thể bị ghi đè :
    • this.method()
    • this.property
  • riêng tĩnh không ghi đè phương pháp / getter:
    • Foo.method()
    • Foo.property
  • riêng trường hợp không ghi đè phương pháp / getter:
    • không thể có chủ ý trừ khi sử dụng một số cách giải quyết :
      • Foo.prototype.method.call( this )
      • Object.getOwnPropertyDescriptor( Foo.prototype,"property" ).get.call(this);

Hãy nhớ rằng việc sử dụng thiskhông hoạt động theo cách này khi sử dụng các hàm mũi tên hoặc gọi các phương thức / getters ràng buộc rõ ràng với giá trị tùy chỉnh.

Lý lịch

• Khi trong bối cảnh của một phương thức hoặc getter của một thể hiện
  • this đang đề cập đến ví dụ hiện tại.
  • super về cơ bản là đề cập đến cùng một thể hiện, nhưng phần nào giải quyết các phương thức và getters được viết trong ngữ cảnh của một số lớp hiện tại đang mở rộng (bằng cách sử dụng nguyên mẫu của nguyên mẫu của Foo).
  • định nghĩa của lớp thể hiện được sử dụng để tạo nó có sẵn cho mỗi this.constructor.
• Khi trong bối cảnh của một phương thức tĩnh hoặc getter không có "trường hợp hiện tại" theo ý định và vì vậy
  • this có sẵn để tham khảo định nghĩa của lớp hiện tại trực tiếp.
  • super cũng không đề cập đến một số trường hợp, mà là các phương thức tĩnh và getters được viết trong ngữ cảnh của một số lớp hiện tại đang mở rộng.

Phần kết luận

Hãy thử mã này:

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

Nếu bạn đang có kế hoạch thực hiện bất kỳ loại thừa kế, thì tôi muốn giới thiệu this.constructor. Ví dụ đơn giản này sẽ minh họa tại sao:

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()sẽ đăng nhập ConstructorSuper Hello ConstructorSuper!vào giao diện điều khiển
• test2.callPrint()sẽ đăng nhập ConstructorSub Hello ConstructorSub!vào giao diện điều khiển

Lớp được đặt tên sẽ không xử lý sự kế thừa độc đáo trừ khi bạn xác định lại rõ ràng mọi chức năng tạo tham chiếu đến Lớp được đặt tên. Đây là một ví dụ:

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()sẽ đăng nhập NamedSuper Hello NamedSuper!vào giao diện điều khiển
• test4.callPrint()sẽ đăng nhập NamedSuper Hello NamedSub!vào giao diện điều khiển

Xem tất cả các hoạt động ở trên trong Babel REPL .

Bạn có thể thấy từ đây mà test4vẫn nghĩ rằng nó thuộc siêu hạng; trong ví dụ này có vẻ như không phải là một vấn đề lớn, nhưng nếu bạn đang cố gắng tham chiếu các hàm thành viên đã bị ghi đè hoặc biến thành viên mới, bạn sẽ thấy mình gặp rắc rối.