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
muy buena explicación ... gracias. – Anshul
no lo consigo :( –
así que ¿cuál es una diferencia o ventaja en la definición de la función en la función constructor y entre definirlo en prototipo como: constructor.prototype.func = function () {}; –