Pregunta sobre el estilo OOP funcional en JavaScript

Question

Prefiero usar el estilo OOP funcional para mi código (similar al patrón de módulo) porque me ayuda a evitar la palabra clave "nueva" y todos los problemas con el alcance de la palabra clave "this" en devoluciones de llamada.

Pero me he encontrado con algunos problemas menores. Me gustaría utilizar el siguiente código para crear una clase.

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

El problema es que no puedo llamar a los métodos públicos desde mi código de inicialización, ya que estas funciones aún no están definidas. La solución obvia sería crear un método init y llamarlo antes de la línea "return self". Pero tal vez conoces una solución más elegante?

Además, ¿cómo manejas la herencia con este patrón? Utilizo el siguiente código, pero me gustaría escuchar sus ideas y sugerencias.

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

Editar. Para los que preguntó cuáles son las razones para elegir este estilo de programación orientada a objetos, se puede mirar en las preguntas siguientes:

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

Answer 1

Estoy de acuerdo con casi todas comentario o respuesta proporcionada hasta ahora, pero que tomo de Tim respuesta un paso más allá - cuestionó por qué usted quiere llamar a un método antes de que se definió, pero ofrecieron una solución de todos modos, mientras que yo le sugeriría no debería llamada antes de definir (no sé de ningún idioma en que llamar a un método antes de definir o al menos declarar que se considera una buena práctica), entonces ¿qué:

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

¿Hay alguna razón en particular por la que esto no funcione para usted?

Answer 2

Varias preguntas se me ocurren, tales como por qué desea evitar el operador new, y por qué desea llamar a las funciones antes de que se definan. Sin embargo, dejando a un lado, ¿qué tal algo así como lo siguiente?

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

Esta es la solución que mencioné en la pregunta. Sus comentarios son bienvenidos

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

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

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

    init(); 
    return self; 
} 

Answer 4

Puede utilizar Zet.js biblioteca que le ayudará con declarar clases en la forma que desee.