Prototyp für private Unter Methoden

Question

Ich habe Code, der wie folgt aussieht:

var baseClass = function() { 
// CODE 
    var subClass = function() { 
     // MORE CODE 
    } 
} 

Methoden zur Basisklasse Hinzufügen ist in Ordnung, ich verwende nur

baseClass.prototype.newMethod = function() { 
    // NEW CODE 
} 

Meine Frage ist, wie sollte ich hinzufügen Methoden Unterklasse? Ist der einzige Weg, um es einfach zu einer öffentlichen Methode zu machen?

######## BEARBEITEN ##############

OK, also habe ich den Code neu angeordnet, so dass die Unterklasse außerhalb der Basisklasse ist. Ich übergebe BaseClass, so dass SubClass weiterhin auf die Eigenschaften der Instanz von BaseClass zugreifen kann.

var baseClass = function() { 
    var base = this; 
    this.property_a = 1; 
    this.property_b = 5; 

    var sub = new subClass(base); 
    // CODE 
} 

var subClass = function(parent) { 
    var sub = this; 
    this.property_c = 1; 
    this.method_a = function() { 
     return sub.property_c + parent.property_a; 
    } 
    // MORE CODE 
} 

das ist in Ordnung und funktioniert, aber ich habe jetzt ein neues Problem, wenn ich eine Methode Prototyp hinzufügen:

subClass.prototype.method_b = function(){ 
    return sub.property_c + parent.property_b; 
} 

ich einen Fehler sagen Eltern nicht definiert ist.

Grundsätzlich habe ich eine ziemlich einfache Webanwendung, die zwei Seiten hat, eine Betrachtungsseite und eine Bearbeitungsseite. Ich erstelle die Basisklasse, die alles enthält, was zum Anzeigen benötigt wird, und ich möchte die Methoden hinzufügen, die für die Bearbeitung in einer anderen Datei erforderlich sind, damit sie nur geladen werden, wenn sich ein Benutzer auf der Bearbeitungsseite befindet.

Answer 1

Warum deklarieren Sie diese Unterklasse in der Basisklasse? Für mich ergibt das keinen Sinn.

Sie können dem Prototyp der Unterklasse hinzufügen, wo immer er sich in Ihrem Bereich befindet. In Ihrem Code wäre es

var baseClass = function() { 
// CODE 
    var subClass = function() { 
     // MORE CODE 
    } 
    subClass.prototype = { 
     ... 
    } 
} 

Aber ich würde vorschlagen, es aus dem Basisklassenkonstruktor heraus zu setzen. Wenn Sie es aus irgendeinem Grund privat wollen, fügen Sie eine Schließung:

(function(){ 

    baseClass = function() { // public 
     // CODE 
    } 
    baseClass.prototype = {...}; 

    var subClass = function() { // private 
     // MORE CODE 
    } 
    subClass.prototype = Object.create(baseClass.prototype); 
    subClass.prototype.newMethod = function() { ... } 
})() 

---

EDIT die erweiterte Frage zu beantworten:

Ah, Subklasse erbt nicht von Baseclass! Wir hatten das erwartet, sonst könnte es in Ordnung sein, es im Konstruktor zu haben.Dann könnte der gleiche Prototyp zu jedem der verschiedenen Unterklasse Konstrukteuren wurden hinzugefügt:

var subproto = { 
    method_b: = function(){ 
     // manipulate "this" 
    }, 
    ... 
}; 
function baseClass() { 
    // some code 
    function sub() { 
     // is a constructor for subs which belong to this specif base intance 
     ... 
    } 
    sub.prototype = subproto; // the sub constructors of each base instance 
           // have the same prototype 
    var x = new sub(), 
     y = new sub(); // example usage of the sub constructor 
} 
baseClass.prototype = {...} 

Else, wenn Sie einen gemeinsamen Unter Konstruktor wollen (außerhalb der Funktion Baseclass), können Sie die Basis-Instanz geben, gehört die Unter zu als ein Argument für den Konstruktor - wie Sie es getan haben. Natürlich kann das Subsystem (sowohl interne als auch externe Methoden) nur auf öffentliche Eigenschaften dieser Basisinstanz zugreifen.

Der Fehler, den Sie in Ihrem neu angeordneten Code gemacht haben, ist, dass Ihre Prototyp-Methoden ("externe") versuchten, auf die private parent-Variable aus dem Unterkonstruktor zuzugreifen. Wie du sagst, "Fehler beim Sagen des Elternteils ist nicht definiert".

var subClass = function(parent) { 
    var sub = this; 
    this.parent = parent; // make it public 
    this.property_c = 1; 
    this.method_a = function() { 
     return sub.property_c + parent.property_a; 
    } 
    // MORE CODE 
} 
subClass.prototype.method_b = function(){ 
    // prototype functions can only access public properties 
    // i.e. privileged methods, public attributes and other prototype properties 
    return this.property_c + this.parent.property_b; 
} 

Answer 2

Wenn Sie wirklich die Unterklasse privat halten möchten, können Sie die Definitionen in einem Verschluss verbergen konnte:

var BaseClass = (function() { 
    function BaseClass() { ... }; 
    function SubClass() { ... }; 
    BaseClass.prototype.foo = function() { ... }; 
    SubClass.prototype.foo = function() { ... }; 
    return BaseClass; 
})(); 

Ich habe persönlich diese Art von Schließung erzwungene Schutz gefunden mehr Ärger als es wert ist (ex , macht das Debuggen schwieriger) ... Aber wenn du es machen wolltest, so würdest du es tun.

Answer 3

Sie werden die Methoden im gleichen Kontext definieren, wie Sie subClass definieren:

var baseClass = function() { 
    // CODE 
    var subClass = function() { 
     // MORE CODE 
    } 
    subClass.prototype.newMethod = function() { ... } 
} 

Wenn das nicht möglich ist, dann müssen Sie subClass in dem entsprechenden Kontext belichten oder einen Mechanismus von baseClass bieten zu Erweitern Sie subClass.