Como se mencionó, las películas de Douglas Crockford dan una buena explicación sobre el por qué y cubre el cómo. Pero para ponerlo en un par de líneas de JavaScript:
// Declaring our Animal object
var Animal = function() {
this.name = 'unknown';
this.getName = function() {
return this.name;
}
return this;
};
// Declaring our Dog object
var Dog = function() {
// A private variable here
var private = 42;
// overriding the name
this.name = "Bello";
// Implementing ".bark()"
this.bark = function() {
return 'MEOW';
}
return this;
};
// Dog extends animal
Dog.prototype = new Animal();
// -- Done declaring --
// Creating an instance of Dog.
var dog = new Dog();
// Proving our case
console.log(
"Is dog an instance of Dog? ", dog instanceof Dog, "\n",
"Is dog an instance of Animal? ", dog instanceof Animal, "\n",
dog.bark() +"\n", // Should be: "MEOW"
dog.getName() +"\n", // Should be: "Bello"
dog.private +"\n" // Should be: 'undefined'
);
El problema con este enfoque, sin embargo, es que va a volver a crear el objeto cada vez que cree una. Otro enfoque es declarar sus objetos en la pila prototipo, así:
// Defining test one, prototypal
var testOne = function() {};
testOne.prototype = (function() {
var me = {}, privateVariable = 42;
me.someMethod = function() {
return privateVariable;
};
me.publicVariable = "foo bar";
me.anotherMethod = function() {
return this.publicVariable;
};
return me;
}());
// Defining test two, function
var testTwo = function() {
var me = {}, privateVariable = 42;
me.someMethod = function() {
return privateVariable;
};
me.publicVariable = "foo bar";
me.anotherMethod = function() {
return this.publicVariable;
};
return me;
};
// Proving that both techniques are functionally identical
var resultTestOne = new testOne(),
resultTestTwo = new testTwo();
console.log(
resultTestOne.someMethod(), // Should print 42
resultTestOne.publicVariable // Should print "foo bar"
);
console.log(
resultTestTwo.someMethod(), // Should print 42
resultTestTwo.publicVariable // Should print "foo bar"
);
// Performance benchmark start
var stop, start, loopCount = 1000000;
// Running testOne
start = (new Date()).getTime();
for (var i = loopCount; i>0; i--) {
new testOne();
}
stop = (new Date()).getTime();
console.log('Test one took: '+ Math.round(((stop/1000) - (start/1000))*1000) +' milliseconds');
// Running testTwo
start = (new Date()).getTime();
for (var i = loopCount; i>0; i--) {
new testTwo();
}
stop = (new Date()).getTime();
console.log('Test two took: '+ Math.round(((stop/1000) - (start/1000))*1000) +' milliseconds');
Hay un pequeño inconveniente cuando se trata de la introspección. El dumping de TestOne dará como resultado información menos útil. También la propiedad privada "privateVariable" en "testOne" se comparte en todas las instancias, como se menciona amablemente en las respuestas de shesek.
¿Recibió la oportunidad de comprobar que la biblioteca Base? Realmente es lindo, y bastante pequeño. Si te gusta, considera marcar mi respuesta como la respuesta. TIA, Roland. –
Supongo que estoy en el mismo barco que tú. También quiero aprender un poco sobre este lenguaje prototípico, no estar restringido solo a los marcos de oop o similares, incluso si son geniales y todo, tenemos que aprender, ¿no? No solo un marco de trabajo hace eso por mí, incluso si lo voy a usar. Pero aprende a crear cosas nuevas en nuevos idiomas con nuevas formas, piensa fuera de la caja. Me gusta tu estilo. Voy a intentar ayudarme y tal vez ayudarte. Tan pronto como encuentre algo, se lo haré saber. –