Frage zum funktionalen OOP-Stil in JavaScript

Question

Ich bevorzuge funktionale OOP-Stil für meinen Code (ähnlich dem Modulmuster), weil es mir hilft, das "neue" Schlüsselwort und alle Probleme mit dem Geltungsbereich von "diesem" Schlüsselwort zu vermeiden Rückrufe.

Aber ich habe ein paar kleinere Probleme damit zu tun. Ich möchte den folgenden Code verwenden, um eine Klasse zu erstellen.

namespace.myClass = function(){ 
    var self = {}, 
     somePrivateVar1; 

    // initialization code that would call 
    // private or public methods 
    privateMethod(); 
    self.publicMethod(); // sorry, error here 

    function privateMethod(){} 

    self.publicMethod = function(){}; 

    return self; 
} 

Das Problem ist, dass ich öffentliche Methoden aus meinem Initialisierungscode nicht aufrufen kann, da diese Funktionen noch nicht definiert sind. Die offensichtliche Lösung wäre, eine Init-Methode zu erstellen und sie vor der "return self" -Zeile aufzurufen. Aber vielleicht kennen Sie eine elegantere Lösung?

Auch, wie behandeln Sie normalerweise Vererbung mit diesem Muster? Ich benutze den folgenden Code, aber ich würde gerne Ihre Ideen und Vorschläge hören.

namespace.myClass2 = function(){ 
    var self = namespace.parentClass(), 
     somePrivateVar1;    

    var superMethod = self.someMethod; 
    self.someMethod = function(){ 
    // example shows how to overwrite parent methods 
    superMethod(); 
    }; 

    return self; 
} 

Bearbeiten. Für diejenigen, die Frage, was die Gründe für die Wahl dieses Stils der OOP sind, können Sie folgende Fragen prüfen können:

• Prototypal vs Functional OOP in JavaScript
• Is JavaScript's "new" keyword considered harmful?

Answer 1

ich mit fast jedem Kommentar zustimmen oder so weit vorgesehen Antwort, aber weiter Tims Antwort einen Schritt zu nehmen - er die Frage, warum Sie eine Methode aufrufen wollen würde, bevor sie definiert wurde, bot aber trotzdem eine Lösung, während ich Sie sollte vor dem definieren nicht Aufruf vorschlagen würde (ich weiß nicht, jeder Sprache, in der Definition es vor Aufruf einer Methode oder zumindest erklären, gute Praxis betrachtet), so wie etwa:

namespace.myClass = function(){ 
    //declare private vars (and self) first 
    var self = {}, 
     somePrivateVar1; 

    //then declare private methods 
    function privateMethod(){} 

    //then public/privileged methods 
    self.publicMethod = function(){}; 

    // THEN (and only then) add your 
    // initialization code that would call 
    // private or public methods 
    privateMethod(); 
    self.publicMethod(); // no error any more 

    //then return the new object 
    return self; 
} 

Gibt es einen bestimmten Grund, warum dies nicht für Sie arbeiten würde?

Answer 2

Mehr Fragen kommen zu mir, wie, warum Sie möchte den Operator new vermeiden und warum Sie Funktionen aufrufen möchten, bevor sie definiert sind. Aber abgesehen davon, wie wäre es mit etwas wie dem folgenden?

namespace.myClass = function(){ 
    var somePrivateVar1; 
    var self = {}; 

    // initialization code that would call 
    // private or public methods 
    privateMethod(); 
    publicMethod(); 

    function privateMethod(){} 
    function publicMethod(){} 

    self.publicMethod = publicMethod; 
    return self; 
} 

Answer 3

Dies ist die Lösung, die ich in der Frage erwähnt habe. Ihre Kommentare sind willkommen.

namespace.myClass = function(){ 
    var self = {}, 
     somePrivateVar1; 

    function init(){ 
    privateMethod(); 
    self.publicMethod(); 
    } 

    function privateMethod(){} 
    self.publicMethod = function(){}; 

    init(); 
    return self; 
} 

Answer 4

können Sie Zet.js Bibliothek verwenden, die Sie mit erklären Klassen in der Art und Weise helfen Sie wollen.