JavaScript Explicación del prototipo necesaria

Question

Normalmente, en mi proyecto creo mi clase de esta manera ... Objeto literal.

var objectName = { 

    //global variables 
     a : 'somevalue', 

     func1: function(){ 

     }, 


     func2: function(){ 

     } 

} 

Si tengo que convertir esto en formato de prototipo, ¿cómo lo haría?

¿Cuál sería mi ventaja de usar un prototipo que no sea este, cuando el trabajo se está haciendo con este formato?

¿Por qué la gente habla tanto de prototipos?

Answer 1

se convirtió en un prototipo sería algo como:

var someObject = function() { 
    this.a = "somevalue"; 
}; 

someObject.prototype.func1 = function() { // work }; 
someObject.prototype.func2 = function() { // work }; 

var myObject = new someObject(); 

Cuáles son las ventajas? Bueno, hay un montón, pero hay son un puñado de razones realmente prácticas cuando los prototipos hacen que tenga más sentido que los literales de objeto.

Primero es la reducción del código duplicado; Por lo tanto, digamos que quería otro objeto muy similar a objectName, pero quería a a tener un valor diferente. Es probable que terminar con algo como:

var objectName = { 
     a : 'somevalue', 
     func1: function(){ }, 
     func2: function(){ } 
} 

var otherObjectName = { 
     a : 'otherValue', 
     func1: function(){ }, 
     func2: function(){ } 
} 

Y se podría reducir las funciones duplicadas diciendo

var objectName = { 
     a : 'somevalue', 
     func1: function(){ }, 
     func2: function(){ } 
} 

var otherObjectName = { 
     a : 'otherValue', 
     func1: objectName.func1, 
     func2: objectName.func2 
} 

O, usando un prototipo, tan sólo pudiera hacerlo por lo que podría pasar en el valor Quiero a durante la construcción del objeto. El código refactorizado sería algo como esto:

var someObject = function(a) { 
    this.a = a; 
}; 

someObject.prototype.func1 = function() { /* work */ }; 
someObject.prototype.func2 = function() { /* work */ }; 

var myObject = new someObject("somevalue"); 
var myOtherObject = new someObject("otherValue"); 

Ahora, si quería agregar una nueva función a ambos. Utilizando el objeto literal apporach, entonces debería recordar agregarlo también a otherObjectName. A medida que aumente el número de tus literales, tomaría más tiempo y será más difícil administrarlos todos.

Utilizando el enfoque de prototipo, todos tendríamos que decir es:

someObject.prototype.func3 = function() { // do even more work } 

o incluso más interesante que pude extender dinámicamente tanto objeto sólo tener una referencia a uno diciendo.

// find what function made me, get its prototype, and add a new function to it 
myObject.constructor.prototype.func3 = function() { /* work */ } 
myOtherObject.func3() // tada magic! 

o podría hacer un nuevo objeto, solo conociendo una referencia. como:

var newObject = myObject.constructor(myObject.a + " new"); 

Debido a que tanto myObject y myOtherObject comparten el mismo constructor y prototype, hay un montón de cosas interesantes que puede hacer con esa relación que no se puede hacer con objetos literales.

Puede pensar en prototipos como pequeñas fábricas para crear objetos en lugar de tener que crear cada objeto usted mismo como un literal.

Ahora, si estás pensando, "Bueno, solo voy a tener uno de estos y no voy a estar haciendo ninguno de tus métodos locos extendiendo la magia."Entonces, definir un objeto literal es un apporach perfectamente válido para algunos problemas. A veces es mejor usar un prototipo. Use el patrón que tenga sentido para el problema que está tratando de resolver, en lugar de tratar de encajar su problema en un patrón