{8} Comentarios.

1. 

   Israel

   17May2011/

   Muy bueno el artículo aunque no me ha quedado clara la diferencia entre usar «call» ó «aply» (a parte de lo evidente).
2. 

   pedro

   06Sep2011/

   ¿como se consigue hacer una clase que herede de otra con este patron? Es decir, tengo mi clase var myApp = {};
   (function(){//lo que haga la clase}).apply( myApp ); y quiero crear una segunda clase usando este mismo patron que extienda de la primera… estoy intentandolo pero no doy con la tecla…
3. 

   pedro

   08Sep2011/

   me lie, basta con myApp.mySubApp = {};
   (function(){//lo que haga la clase}).apply( myApp.mySubApp );
4. 

   maparrar

   07May2012/

   Hola, hace un tiempo uso una estructura como la siguiente para generar objetos a partir de «clases» (entiendo que uno se debería olvidar de las clases en javascript), sin embargo me ha funcionado bastante bien. Noto que hay algún parecido con el patrón Proxy, sin usar apply. Quisiera saber si cometo errores al usar esta estructura, o si incluyo fallas de seguridad.

   Foo=function(param1,param2){
       //Create an obj variable to manage this without conflicts with another this uses
       var obj=this;
       //Private variables
       var priVar=0;
       var parameter1=param1;
       var parameter2=param2;
       
       //Private Methods
       var privateMethod=function(){
           console.debug("I'm a private method, only accesible from the Object");
       };
       
       //Public Methods
       obj.decrement=function(){
           console.debug(--priVar);
       }
       obj.increment=function(){
           console.debug(++priVar);
       }
       obj.getParam=function(){
           console.debug("The parameter1 passsed in constructor is: "+parameter1+" - parameter 2: "+parameter2);
       }
       obj.usePrivateMethod=function(){
           privateMethod();
       }
   };
   
   //Uso de la "clase"
   var foo=new Foo("parameterValue","another");
   foo.increment();
   foo.decrement();
   foo.getParam();
   foo.usePrivateMethod();
   

   • 

     Carlos Benítez

     07May2012/

     No hay ningún problema con la estructura que planteas; durante años, la programación con objetos en Javascript se ha desarrollado con un patrón similar al que propones: constructores y herencia prototípica.

     En tu caso, Foo, (que por cierto has olvidado declarar con ‘var’), actúa como un constructor al que se precisa instanciar como una ‘clase’ estándar; tras ello, mediante herencia prototípica, se van estableciendo sus métodos públicos dejando el resto de funciones internas como privadas.

     Los patrones ‘modernos’, lo que buscan es ‘homogeneizar’ la estructura interna de los objetos para organizarla en Javascript puro, es decir, sin tratar de imitar las características o funcionalidades a las que podemos estar acostumbrados en otros lenguajes. De ahí que ni siquiera hablemos de clases sino de prototipos y que optemos por esquemas donde todos los métodos internos de un objeto, se declaren de la misma forma para, solo en un determinado punto, hacerlos públicos o no.

     Como ves, es solo una cuestión de ‘organización’ interna… Tu código, o forma, es perfectamente válido.

     Saludos.
5. 

   Mario

   09Jul2012/

   Hola, en la implementación del patrón módulo clásico me gustó mucho cuando pasamos el objeto window a nuestra función autoejecutable y de hecho noté un poco más rápido mi código (aparentemente).
   Mi duda es si esta ventaja no se pierde al utilizar el patron proxy.
6. 

   dhamaso

   13Jul2013/

   Hola, yo utilizo este patrón de diseño (Por que lo aprendí aquí y gracias a usted) y me gustaría saber la mejor forma de utilizar la herencia con este tipo de estructura.

   he visto que Pedro plantea una solución:

   myApp.mySubApp

   ¿Pero esa es la mejor forma de hacer esto?

   De antemano gracias y un saludo desde México.
7. 

   dhamaso

   13Jul2013/

   Otra vez yo; Probé el código de Pedro, pero en lugar de hacer una herencia lo que hace es crear un objeto dentro del objeto myApp:

   myApp.mySubApp

   mySubApp no tiene acceso a las propiedades y métodos del objeto padre, ni las puede sobrescribir.

   Y lo que yo intento hacer es algo como esto:

   /**
   * Clase Padre
   */
   var CORE = (CORE || {});
   (function(window,document,$,undefined){
   var self = this;
   var defaults = {
   ‘a’ : null,
   ‘b’ : null
   };
   this.init = function(options){
   self.settings = $.extend({}, defaults, options);
   return this;
   };
   this.run = function(){
   // hacer algo aqui
   };
   this.sayHi = function(){
   return defaults.a + ‘ ‘ + defaults.b;
   };
   }).apply(CORE, [window, window.document, jQuery]);

   /**
   * Clase hija
   */
   var APP = (APP || {});
   (function(window,document,$,undefined){
   this.run = function(){
   // Sobrescribir el método padre
   };
   }).apply(APP, [window, window.document, jQuery]);

   // Poder llamar
   APP.sayHi();

   ¿Algo así se puede hacer con este patrón?