일반 ES6 클래스 메서드에서 스태틱 메서드를 호출합니다.

일반 ES6 클래스 메서드에서 스태틱 메서드를 호출합니다.

스태틱 메서드라고 하는 표준 방법은 무엇입니까?사용할 수 있습니다.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의 정적 메서드/게터로부터
  • 일부 static 메서드/getter는 오버라이드될 수 있습니다.
    • this.method()
    • this.property
  • 일부 instance method/getter는 오버라이드될 수 있습니다.
    • 설계상 불가능한
  • 자신의 비방해 정적 메서드/getter:
    • Foo.method()
    • Foo.property
  • 자체 비방해 인스턴스 메서드/getter:
    • 설계상 불가능한
• Foo의 인스턴스 메서드/getter에서
  • 일부 static 메서드/getter는 오버라이드될 수 있습니다.
    • this.constructor.method()
    • this.constructor.property
  • 일부 instance method/getter는 오버라이드될 수 있습니다.
    • this.method()
    • this.property
  • 자신의 비방해 정적 메서드/getter:
    • Foo.method()
    • Foo.property
  • 자체 비방해 인스턴스 메서드/getter:
    • 다음과 같은 회피책을 사용하지 않는 한 고의로 할 수 없습니다.
      • Foo.prototype.method.call( this )
      • Object.getOwnPropertyDescriptor( Foo.prototype,"property" ).get.call(this);

를 사용하는 것에 주의해 주세요.this화살표 함수를 사용하거나 커스텀 값에 명시적으로 바인드된 메서드/게터를 호출할 때는 이 방법으로 동작하지 않습니다.

배경

• "getter" "getter" "getter"
  • this현재 인스턴스를 참조하고 있습니다.
  • super는 기본적으로 동일한 인스턴스를 참조하고 있지만, (Foo의 프로토타입을 사용하여) 일부 클래스 전류와 관련하여 작성된 메서드와 getter에 대한 대응이 확장되고 있습니다.
  • 인스턴스 작성에 사용되는 인스턴스 클래스의 정의는 다음 항목에서 사용할 수 있습니다.this.constructor.
• 정적 메서드 또는 getter의 컨텍스트에서는 의도적인 "현재 인스턴스"가 존재하지 않습니다.
  • this는 현재 클래스의 정의를 직접 참조할 수 있습니다.
  • super는 일부 인스턴스를 참조하는 것이 아니라 현재 확장 중인 클래스의 컨텍스트에서 작성된 정적 메서드와 getter를 참조하는 것입니다.

결론

다음 코드를 사용해 보십시오.

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이 예에서는 그것이 슈퍼클래스에 속한다고 생각할 수 있습니다.이 예에서는 큰 문제가 아닌 것처럼 보일 수 있지만 오버라이드된 멤버 함수나 새로운 멤버 변수를 참조하려고 하면 문제가 발생합니다.

언급URL : https://stackoverflow.com/questions/28627908/call-static-methods-from-regular-es6-class-methods