JavaScript 클래스에서 부모 메소드를 호출하지만 객체 인스턴스 내부의 프로토 타입 메소드에 액세스 할 수 있습니까?

Question

JavaScript 클래스에서 부모 메서드를 호출 할 수 있지만 부모 클래스와 자식 클래스의 프로토 타입 메서드에 계속 액세스 할 수 있습니까?

var Base = function() { 

    this.baseMethod = function(){ 
    return 'baseMethod'; 
    }; 

    this.baseInitMethod = function() { 
    return 'baseInitMethod'; 
    } 
} 


Base.prototype.basePrototypeMethod = function() { 
    return "basePrototypeMethod"; 
}; 


var Specific = function() { 

    Base.call(this); 

    this.baseInitMethod = function() { 
    // call baseInitMethod from Base class 
    } 

    this.specificMethod = function(){ 
    return 'specificMethod'; 
    } 

    this.specificInitMethod = function() { 

    return this.basePrototypeMethod(); 
    } 
} 


Specific.prototype.specificPrototypeMethod = function() { 
    return 'specificPrototypeMethod' + '-' + this.baseInitMethod(); 
} 


for(var p in Base.prototype) { 
    Specific.prototype[p] = Base.prototype[p] 
} 


var s = new Specific(); 


console.log(s.baseMethod()); 

console.log(s.baseInitMethod()); 

console.log(s.basePrototypeMethod()); 

console.log(s.specificMethod()); 

console.log(s.specificInitMethod()); 

console.log(s.specificPrototypeMethod()); 

내가 특정 클래스 내부에 있지만, 그래서 모든 기능은 계속 작동 이상에서 호출하는 baseInitMethod 방법에서 기본 클래스에 baseInitMethod를 호출 할 : 다음 코드 예제입니다. 그게 가능하니? Specific의 정의와,

var Base = function() { 
}; 
Base.prototype.baseMethod = function() { 
    return 'baseMethod'; 
}; 
Base.prototype.baseInitMethod = function() { 
    return 'baseInitMethod'; 
}; 
Base.prototype.basePrototypeMethod = function() { 
    return "basePrototypeMethod"; 
}; 


var Specific = function() { 
    Base.apply(this, arguments); 
}; 
Specific.prototype.baseInitMethod = function() { 
    Base.prototype.baseInitMethod.apply(this,arguments); 
}; 

Specific.prototype.specificMethod = function() { 
    return 'specificMethod'; 
}; 

Specific.prototype.specificInitMethod = function() { 
    var basePrototypeMethodCallResult = Base.prototype.basePrototypeMethod.apply(this,arguments); 

}; 

Answer 1

귀하의 Specific.prototype 객체가 Base.prototype 개체에서을 상속합니다.

for(var p in Base.prototype) { 
    Specific.prototype[p] = Base.prototype[p] 
} 

그러나 당신은 실제로 진짜 프로토 타입 체인 설정 Object.create를 사용해야합니다 : : 현재이 코드를 사용하여 객체의 모든 속성을 통해 복사하는

Specific.prototype = Object.create(Base.prototype); 

Specific.prototype.specificPrototypeMethod = function() { 
    return 'specificPrototypeMethod' + '-' + this.baseInitMethod(); 
} 

---

을

baseInitMethod에서 Base 클래스의 baseInitMethod를 호출하려고합니다. hod inside 특정 등급

예. 예. 모든 기능이 계속 작동 이상에서 호출

function Specific() { 
    Base.call(this); 

    var parentInitMethod = this.baseInitMethod; 
    this.baseInitMethod = function() { 
     // call baseInitMethod from Base class: 
     parentInitMethod.call(this /*, arguments…*/); 
    } 

    … 
} 

그래서 : 당신의 Specific 생성자에서 먼저 인스턴스의 속성을 덮어 쓰기 전에, Base의 baseInitMethod 인스턴스 메소드를 얻을 필요가있다.

정확히 무슨 뜻인지 잘 모르겠습니다. specificPrototypeMethod은 항상 현재 인스턴스의 baseInitMethod을 호출합니다. Specific은 Base에 정의 된 원본이 아닌 덮어 씁니다.

Answer 2

은 당신이 할 필요가 무엇인가? 당신은 단순히 함수의 덮어 쓰기를 제거하면 당신은 기본 정의를 호출해야합니다 :

var Base = function() { 

    this.baseMethod = function(){ 
    return 'baseMethod'; 
    }; 

    this.baseInitMethod = function() { 
    return 'baseInitMethod'; 
    } 
} 


Base.prototype.basePrototypeMethod = function() { 
    return "basePrototypeMethod"; 
}; 


var Specific = function() { 

    Base.call(this); 

    this.baseInitMethod(); // calls the Base definition only 

    this.specificMethod = function(){ 
    return 'specificMethod'; 
    } 

    this.specificInitMethod = function() { 

    return this.basePrototypeMethod(); 
    } 
} 

Answer 3

을 당신은 Specific 내부 Base의 baseInitMethod 덮어 쓰기를하고, 왜 당신은 이제까지 기본 버전을 호출 할 것이다 : 여기

Answer 4

"왜 항상 고전적인 행동을 모방하려고 노력하고 대신 프로토 타입 위임 패턴을 수용하는 대신 call과 apply을 사용하여 혼란에 빠지겠습니까?" 여기

내가 코드를 할 것입니다 : 확실히 당신이 휴식 상속의 규칙을 원하는

var Base = { 

    baseVariable1: "baseValue1", 

    baseVariable2: "baseValue2", 

    baseMethod: function() { 
     return 'baseMethod'; 
    }, 

    baseInitMethod: function() { 
     return 'baseInitMethod'; 
    } 
} 

var Specific = Object.create(Base); 

Specific.variable1 = "value1"; 

Specific.variable2 = "value2"; 

Specific.specificInitMethod = function() { 
    return 'specificInitMethod' + '-' + this.baseInitMethod(); 
} 

Specific.specificMethod = function() { 
    return 'specificMethod' + '-' + this.baseInitMethod(); 
} 

var s = Object.create(Specific); 

console.log(s.baseInitMethod()); 

console.log(s.baseVariable1); 

console.log(s.baseVariable2); 

console.log(s.variable1); 

console.log(s.variable2); 

console.log(s.baseMethod()); 

console.log(s.specificInitMethod()); 

console.log(s.specificMethod());