cómo tener el patrón de creación de objetos JavaScript con métodos reutilizables y propiedades privadas?

Question

Teniendo en cuenta los patrones de creación de objetos con propiedades particulares, una forma de hacerlo es:

function MyStack(){ 
    var list = [], 
     index = 0; 

    this.push = function(val){ 
     return list[index++] = val; 
    }; 
    this.pop = function(){// ...} 
} 

var stack1 = new MyStack();  stack1.push(5); 
var stack2 = new MyStack();  stack2.push(11); 

problema con esto: Cada instancia de la pila tiene su propia copia de los métodos 'empuje' y 'pop'.

Otra forma de implementar método constructor es:

function MyStack(){ 
    this.list = []; 
    this.index = 0; 
} 
MyStack.prototype = { 
    insert: function(val){ 
      return this.list[this.index++] = val; 
     }, 
    pop:function(){//...} 
} 

problema aquí: Perdemos la privacidad de la lista y el índice.

¿Hay alguna manera de que podamos tener ambos métodos reutilizados entre las instancias y la privacidad de las propiedades?

Entiendo que podemos tener esto para los métodos que no operan en ningún estado del objeto, pero estoy hablando más acerca de los métodos que sí operan en el estado.

Answer 1

Sí. He editado este código por lo que en realidad es completamente funcional ya que tuviste la intención de que funcione. Me parece un poco redundante, pero proporciona la capacidad de proporcionar una interfaz pública, pero para mantener sus variables privadas y controlar la forma en que el usuario interactúa con ellas.

function MyStack(){ 
    var list = []; 
    var index = 0; 

    this.getIndex = function(){ 
     return index; 
    } 
    this.setIndex = function(val){ 
     index = val; 
    } 
    this.list = function(val){ 
     if(val){ 
      // setter if a value was provided. Illustrating how you can control 
      // index, which I assume is the point of having these things private 
      // to begin with 
      return list[this.setIndex(this.getIndex() + 1)] = val; 
     } 

     // always return list - acts like a getter 
     return list; 
    } 
} 
MyStack.prototype = { 
    insert: function(val){ 
      return this.list(val); 
     }, 
    pop:function(){} 
} 

var stack1 = new MyStack();  
stack1.insert(5); 
var stack2 = new MyStack();  
stack2.insert(11); 

Answer 2

Creo que en ambos enfoques que mencionó, cuando se crea un objeto utilizando un patrón de constructor, las propiedades se copiarán a sus objetos. Esto lo mencionó para el primer enfoque como la preocupación. Siento que lo mismo se aplicará para el segundo enfoque también junto con su preocupación en este enfoque.

En general vamos al segundo enfoque que mencionaste cuando queremos extender las propiedades de "MyStack" a alguna otra clase.

Digamos que desea extender su MyStack clase para MyTest, como a continuación

var dummy = function(); 
dummy.prototype = MyStack.prototype; 
var MyTest = function(){ 
}; 
MyTest.prototype = new dummy(); // Assigning MyStack properties to MyTest 
var obj = new MyTest(); 

Answer 3

Usted debe comprobar fuera de John Resig Simple Javascript Inheritance. Es una gran lectura, y se ha extendido para proporcionar soporte para partes privadas, acertadamente llamado Privates.js;

Answer 4

Una función de constructor puede devolver cualquier objeto (no es necesario este). Se podría crear una función de constructor, que devuelve un objeto proxy, que contiene métodos proxy para los métodos "reales" del objeto de instancia "real". Esto puede sonar complicado, pero no lo es; aquí es un fragmento de código:

var MyClass = function() { 
    var instanceObj = this; 
    var proxyObj = { 
     myPublicMethod: function() { 
      return instanceObj.myPublicMethod.apply(instanceObj, arguments); 
     } 
    } 
    return proxyObj; 
}; 
MyClass.prototype = { 
    _myPrivateMethod: function() { 
     ... 
    }, 
    myPublicMethod: function() { 
     ... 
    } 
}; 

Lo bueno es que la creación de proxy puede ser automatizado, si definimos una convención para nombrar los métodos protegidos. Creé una pequeña biblioteca que hace exactamente esto: http://idya.github.com/oolib/