tablas - recorrer tabla javascript
¿Uso de ''prototipo'' vs. ''este'' en JavaScript? (14)
Cuál es la diferencia entre
var A = function () {
this.x = function () {
//do something
};
};
y
var A = function () { };
A.prototype.x = function () {
//do something
};
¿Cual es la diferencia? => Mucho.
Creo que this versión se utiliza para habilitar la encapsulación, es decir, ocultar datos. Ayuda a manipular variables privadas.
Veamos el siguiente ejemplo:
var AdultPerson = function() {
var age;
this.setAge = function(val) {
// some housekeeping
age = val >= 18 && val;
};
this.getAge = function() {
return age;
};
this.isValid = function() {
return !!age;
};
};
Ahora, la estructura del prototype se puede aplicar de la siguiente manera:
Diferentes adultos tienen diferentes edades, pero todos los adultos obtienen los mismos derechos.
Entonces, lo agregamos usando prototipo, en lugar de esto.
AdultPerson.prototype.getRights = function() {
// Should be valid
return this.isValid() && [''Booze'', ''Drive''];
};
Veamos la implementación ahora.
var p1 = new AdultPerson;
p1.setAge(12); // ( age = false )
console.log(p1.getRights()); // false ( Kid alert! )
p1.setAge(19); // ( age = 19 )
console.log(p1.getRights()); // [''Booze'', ''Drive''] ( Welcome AdultPerson )
var p2 = new AdultPerson;
p2.setAge(45);
console.log(p2.getRights()); // The same getRights() method, *** not a new copy of it ***
Espero que esto ayude.
Cada objeto está vinculado a un objeto prototipo. Al intentar acceder a una propiedad que no existe, JavaScript buscará esa propiedad en el objeto prototipo del objeto y la devolverá si existe.
La propiedad prototype de un constructor de función se refiere al objeto prototipo de todas las instancias creadas con esa función cuando se usa new .
En su primer ejemplo, está agregando una propiedad x a cada instancia creada con la función A
var A = function () {
this.x = function () {
//do something
};
};
var a = new A(); // constructor function gets executed
// newly created object gets an ''x'' property
// which is a function
a.x(); // and can be called like this
En el segundo ejemplo, está agregando una propiedad al objeto prototipo al que apuntan todas las instancias creadas con A
var A = function () { };
A.prototype.x = function () {
//do something
};
var a = new A(); // constructor function gets executed
// which does nothing in this example
a.x(); // you are trying to access the ''x'' property of an instance of ''A''
// which does not exist
// so JavaScript looks for that property in the prototype object
// that was defined using the ''prototype'' property of the constructor
En conclusión, en el primer ejemplo se asigna una copia de la función a cada instancia . En el segundo ejemplo, todas las instancias comparten una única copia de la función .
Como han dicho otros en la primera versión, el uso de "esto" hace que cada instancia de la clase A tenga su propia copia independiente del método de función "x". Mientras que usar "prototipo" significará que cada instancia de la clase A usará la misma copia del método "x".
Aquí hay un código para mostrar esta sutil diferencia:
// x is a method assigned to the object using "this"
var A = function () {
this.x = function () { alert(''A''); };
};
A.prototype.updateX = function( value ) {
this.x = function() { alert( value ); }
};
var a1 = new A();
var a2 = new A();
a1.x(); // Displays ''A''
a2.x(); // Also displays ''A''
a1.updateX(''Z'');
a1.x(); // Displays ''Z''
a2.x(); // Still displays ''A''
// Here x is a method assigned to the object using "prototype"
var B = function () { };
B.prototype.x = function () { alert(''B''); };
B.prototype.updateX = function( value ) {
B.prototype.x = function() { alert( value ); }
}
var b1 = new B();
var b2 = new B();
b1.x(); // Displays ''B''
b2.x(); // Also displays ''B''
b1.updateX(''Y'');
b1.x(); // Displays ''Y''
b2.x(); // Also displays ''Y'' because by using prototype we have changed it for all instances
Como han mencionado otros, hay varias razones para elegir un método u otro. Mi muestra solo pretende demostrar claramente la diferencia.
El último problema con el uso de this lugar de un prototype es que cuando se reemplaza un método, el constructor de la clase base aún se referirá al método reemplazado. Considera esto:
BaseClass = function() {
var text = null;
this.setText = function(value) {
text = value + " BaseClass!";
};
this.getText = function() {
return text;
};
this.setText("Hello"); // This always calls BaseClass.setText()
};
SubClass = function() {
// setText is not overridden yet,
// so the constructor calls the superclass'' method
BaseClass.call(this);
// Keeping a reference to the superclass'' method
var super_setText = this.setText;
// Overriding
this.setText = function(value) {
super_setText.call(this, "SubClass says: " + value);
};
};
SubClass.prototype = new BaseClass();
var subClass = new SubClass();
console.log(subClass.getText()); // Hello BaseClass!
subClass.setText("Hello"); // setText is already overridden
console.log(subClass.getText()); // SubClass says: Hello BaseClass!
versus:
BaseClass = function() {
this.setText("Hello"); // This calls the overridden method
};
BaseClass.prototype.setText = function(value) {
this.text = value + " BaseClass!";
};
BaseClass.prototype.getText = function() {
return this.text;
};
SubClass = function() {
// setText is already overridden, so this works as expected
BaseClass.call(this);
};
SubClass.prototype = new BaseClass();
SubClass.prototype.setText = function(value) {
BaseClass.prototype.setText.call(this, "SubClass says: " + value);
};
var subClass = new SubClass();
console.log(subClass.getText()); // SubClass says: Hello BaseClass!
Si piensa que esto no es un problema, entonces depende de si puede vivir sin variables privadas y si tiene la experiencia suficiente para saber una fuga cuando la ve. Además, tener que poner la lógica del constructor después de las definiciones del método es inconveniente.
var A = function (param1) {
var privateVar = null; // Private variable
// Calling this.setPrivateVar(param1) here would be an error
this.setPrivateVar = function (value) {
privateVar = value;
console.log("setPrivateVar value set to: " + value);
// param1 is still here, possible memory leak
console.log("setPrivateVar has param1: " + param1);
};
// The constructor logic starts here possibly after
// many lines of code that define methods
this.setPrivateVar(param1); // This is valid
};
var a = new A(0);
// setPrivateVar value set to: 0
// setPrivateVar has param1: 0
a.setPrivateVar(1);
//setPrivateVar value set to: 1
//setPrivateVar has param1: 0
versus:
var A = function (param1) {
this.setPublicVar(param1); // This is valid
};
A.prototype.setPublicVar = function (value) {
this.publicVar = value; // No private variable
};
var a = new A(0);
a.setPublicVar(1);
console.log(a.publicVar); // 1
El primer ejemplo cambia la interfaz solo para ese objeto. El segundo ejemplo cambia la interfaz para todos los objetos de esa clase.
En la mayoría de los casos, son esencialmente iguales, pero la segunda versión guarda la memoria porque solo hay una instancia de la función en lugar de una función separada para cada objeto.
Una razón para usar el primer formulario es para acceder a "miembros privados". Por ejemplo:
var A = function () {
var private_var = ...;
this.x = function () {
return private_var;
};
this.setX = function (new_x) {
private_var = new_x;
};
};
Debido a las reglas de alcance de javascript, private_var está disponible para la función asignada a this.x, pero no fuera del objeto.
Los ejemplos tienen resultados muy diferentes.
Antes de mirar las diferencias, se debe tener en cuenta lo siguiente:
- El prototipo de un constructor proporciona una forma de compartir métodos y valores entre las instancias a través de la propiedad privada
[[Prototype]]la instancia. - Esto se establece mediante la forma en que se llama a la función o mediante el uso de bind (no se trata aquí). Cuando se llama a una función en un objeto (por ejemplo,
myObj.method()), esto dentro del método hace referencia al objeto. Cuando esto no se establece por la llamada o por el uso de vinculación , el valor predeterminado para el objeto global (ventana en un navegador) o en modo estricto, permanece indefinido. - JavaScript es un lenguaje orientado a objetos, es decir, todo es un Objeto, incluidas las funciones.
Así que aquí están los fragmentos en cuestión:
var A = function () {
this.x = function () {
//do something
};
};
En este caso, a la variable A se le asigna un valor que es una referencia a una función. Cuando se llama a esa función utilizando A() , la llamada no establece esta función, por lo que se establece de manera predeterminada el objeto global y la expresión this.x es window.x efectiva. El resultado es que una referencia a la expresión de la función en el lado derecho se asigna a window.x .
En el caso de:
var A = function () { };
A.prototype.x = function () {
//do something
};
Ocurre algo muy diferente. En la primera línea, a la variable A se le asigna una referencia a una función. En JavaScript, todos los objetos de funciones tienen una propiedad de prototipo de forma predeterminada, por lo que no hay un código separado para crear un objeto A.prototype .
En la segunda línea, a A.prototype.x se le asigna una referencia a una función. Esto creará una propiedad x si no existe, o asignará un nuevo valor si lo hace. Entonces, la diferencia con el primer ejemplo en el que la propiedad x del objeto está involucrada en la expresión.
Otro ejemplo es el siguiente. Es similar al primero (y quizás a lo que querías preguntar):
var A = new function () {
this.x = function () {
//do something
};
};
En este ejemplo, el new operador se agregó antes de la expresión de la función para que la función se llame como un constructor. Cuando se llama con new , la función está configurada para hacer referencia a un nuevo Objeto cuya propiedad privada [[Prototype]] está configurada para hacer referencia al prototipo público del constructor. Entonces, en la declaración de asignación, la propiedad x se creará en este nuevo objeto. Cuando se llama como un constructor, una función devuelve su objeto por defecto, por lo que no hay necesidad de una return this; por separado return this; declaración.
Para comprobar que A tiene una propiedad x :
console.log(A.x) // function () {
// //do something
// };
Este es un uso poco común de nuevos, ya que la única forma de hacer referencia al constructor es a través de A.constructor . Sería mucho más común hacer:
var A = function () {
this.x = function () {
//do something
};
};
var a = new A();
Otra forma de lograr un resultado similar es usar una expresión de función invocada de inmediato:
var A = (function () {
this.x = function () {
//do something
};
}());
En este caso, A asignó el valor de retorno de llamar a la función en el lado derecho. Nuevamente, ya que esto no está establecido en la llamada, hará referencia al objeto global y this.x es window.x efectivo. Dado que la función no devuelve nada, A tendrá un valor undefined .
Estas diferencias entre los dos enfoques también se manifiestan si está serializando y des-serializando sus objetos Javascript a / desde JSON. Los métodos definidos en el prototipo de un objeto no se serializan cuando serializa el objeto, lo que puede ser conveniente cuando, por ejemplo, desea serializar solo las partes de datos de un objeto, pero no sus métodos:
var A = function () {
this.objectsOwnProperties = "are serialized";
};
A.prototype.prototypeProperties = "are NOT serialized";
var instance = new A();
console.log(instance.prototypeProperties); // "are NOT serialized"
console.log(JSON.stringify(instance));
// {"objectsOwnProperties":"are serialized"}
Preguntas relacionadas :
- ¿Qué significa que JavaScript es un lenguaje prototípico?
- ¿Cuál es el alcance de una función en JavaScript?
- ¿Cómo funciona la palabra clave "this"?
Nota: Es posible que no haya ahorros significativos de memoria entre los dos enfoques, sin embargo, el uso del prototipo para compartir métodos y propiedades probablemente usará menos memoria que cada instancia que tenga su propia copia.
JavaScript no es un lenguaje de bajo nivel. Puede que no sea muy valioso pensar en la creación de prototipos u otros patrones de herencia como una forma de cambiar explícitamente la forma en que se asigna la memoria.
Permítame darle una respuesta más completa que aprendí durante un curso de capacitación de JavaScript.
La mayoría de las respuestas ya mencionaron la diferencia, es decir, cuando se crea un prototipo de la función se comparte con todas las instancias (futuras). Mientras que declarar la función en la clase creará una copia para cada instancia.
En general, no hay correcto o incorrecto, es más una cuestión de gustos o una decisión de diseño que depende de sus requisitos. Sin embargo, el prototipo es la técnica que se utiliza para desarrollarse de manera orientada a objetos, como espero que vea al final de esta respuesta.
Usted mostró dos patrones en su pregunta. Intentaré explicar dos más e intentaré explicar las diferencias si es relevante. Siéntase libre de editar / extender. En todos los ejemplos, se trata de un objeto de automóvil que tiene una ubicación y puede moverse.
Patrón decorador de objetos
No estoy seguro si este patrón sigue siendo relevante hoy en día, pero existe. Y es bueno saberlo. Simplemente pasa un objeto y una propiedad a la función decoradora. El decorador devuelve el objeto con propiedad y método.
var carlike = function(obj, loc) {
obj.loc = loc;
obj.move = function() {
obj.loc++;
};
return obj;
};
var amy = carlike({}, 1);
amy.move();
var ben = carlike({}, 9);
ben.move();
Clases funcionales
Una función en JavaScript es un objeto especializado. Además de ser invocada, una función puede almacenar propiedades como cualquier otro objeto.
En este caso, Car es una función ( también un objeto de pensar) que puede invocarse como solía hacer. Tiene una propiedad de methods (que es un objeto con una función de move ). Cuando se invoca Car llama a la función extend , que hace algo de magia, y extiende la función Car (objeto de pensar) con los métodos definidos dentro de los methods .
Este ejemplo, aunque diferente, se acerca más al primer ejemplo de la pregunta.
var Car = function(loc) {
var obj = {loc: loc};
extend(obj, Car.methods);
return obj;
};
Car.methods = {
move : function() {
this.loc++;
}
};
var amy = Car(1);
amy.move();
var ben = Car(9);
ben.move();
Clases de prototipos
Los dos primeros patrones permiten una discusión sobre el uso de técnicas para definir métodos compartidos o el uso de métodos que se definen en línea en el cuerpo del constructor. En ambos casos, cada instancia tiene su propia función de move .
El patrón prototípico no se presta para el mismo examen, ya que el objetivo del patrón prototípico es compartir funciones a través de una delegación prototipo. Como otros lo señalaron, se espera que tenga una mejor huella de memoria.
Sin embargo, hay un punto interesante que se debe saber: cada objeto prototype tiene un constructor propiedades de conveniencia, que apunta a la función (objeto pensante) a la que se adjuntó.
Respecto a las tres últimas líneas:
En este ejemplo, Car vincula con el objeto prototype , que se vincula a través del constructor con Car , es decir, Car.prototype.constructor es Car . Esto le permite averiguar qué función constructora construyó un determinado objeto.
La búsqueda de amy.constructor falla y, por lo tanto, se delega a Car.prototype , que tiene la propiedad del constructor. Y así es amy.constructor es Car .
Además, amy es una instanceof un Car . El operador instanceof funciona al ver si el objeto prototipo ( Car ) del operando derecho se puede encontrar en algún lugar de la cadena prototipo ( amy ) del operando izquierdo.
var Car = function(loc) {
var obj = Object.create(Car.prototype);
obj.loc = loc;
return obj;
};
Car.prototype.move = function() {
this.loc++;
};
var amy = Car(1);
amy.move();
var ben = Car(9);
ben.move();
console.log(Car.prototype.constructor);
console.log(amy.constructor);
console.log(amy instanceof Car);
Algunos desarrolladores pueden confundirse al principio. Vea el siguiente ejemplo:
var Dog = function() {
return {legs: 4, bark: alert};
};
var fido = Dog();
console.log(fido instanceof Dog);
El operador instanceof devuelve false , porque el prototipo de Dog no se puede encontrar en ninguna parte de la cadena de prototipos de fido . fido es un objeto simple que se crea con un objeto literal, es decir, simplemente delega en Object.prototype .
Patrones seudoclásicos
Esta es solo una forma más del patrón prototípico en forma simplificada y más familiar para aquellos que programan en Java, por ejemplo, ya que utiliza el new constructor.
En realidad, hace lo mismo que en el patrón prototípico, es solo una superposición sintáctica de azúcar del patrón prototípico.
Sin embargo, la principal diferencia es que hay optimizaciones implementadas en los motores de JavaScript que solo se aplican cuando se usa el patrón pseudoclásico. Piense en el patrón pseudoclásico una versión probablemente más rápida del patrón prototípico; Las relaciones de objeto en ambos ejemplos son las mismas.
var Car = function(loc) {
this.loc = loc;
};
Car.prototype.move = function() {
this.loc++;
};
var amy = new Car(1);
amy.move();
var ben = new Car(9);
ben.move();
Finalmente, no debería ser demasiado difícil darse cuenta de cómo se puede realizar la programación orientada a objetos. Hay dos secciones.
Una sección que define propiedades / métodos comunes en el prototipo (cadena).
Y otra sección donde colocas las definiciones que distinguen los objetos entre sí ( loc variable en los ejemplos).
Esto es lo que nos permite aplicar conceptos como superclase o subclase en JavaScript.
Siéntase libre de añadir o editar. Una vez más completo, podría hacer de esto una wiki comunitaria tal vez.
Prototipo es la plantilla de la clase; que se aplica a todas las instancias futuras de la misma. Considerando que esta es la instancia particular del objeto.
Sé que esto ha sido respondido a muerte, pero me gustaría mostrar un ejemplo real de las diferencias de velocidad.
Aquí estamos creando 2,000,000 de nuevos objetos con un método de print en Chrome.Estamos almacenando cada objeto en una matriz. Poner printen el prototipo toma alrededor de 1/2 tiempo.
Toma estos 2 ejemplos:
var A = function() { this.hey = function() { alert(''from A'') } };
contra
var A = function() {}
A.prototype.hey = function() { alert(''from prototype'') };
La mayoría de las personas aquí (especialmente las respuestas más valoradas) intentaron explicar en qué se diferencian sin explicar POR QUÉ. Creo que esto está mal y si primero entiendes los fundamentos, la diferencia se hará evidente. Vamos a tratar de explicar los fundamentos primero ...
a) Una función es un objeto en JavaScript. CADA objeto en JavaScript obtiene una propiedad interna (es decir, no puede acceder a ella como otras propiedades, excepto tal vez en navegadores como Chrome), a menudo denominada __proto__ (en realidad puede escribir anyObject.__proto__ en Chrome para ver a qué se refiere. Esto es solo eso, una propiedad, nada más. Una propiedad en JavaScript = una variable dentro de un objeto, nada más. ¿Qué hacen las variables? Señalan las cosas.
Entonces, ¿a qué __proto__ esta propiedad __proto__ ? Bueno, normalmente otro objeto (explicaremos por qué más adelante). La única forma de forzar JavaScript para que la propiedad __proto__ NO apunte a otro objeto es usar var newObj = Object.create(null) . Incluso si haces esto, la propiedad __proto__ STILL existe como una propiedad del objeto, simplemente no apunta a otro objeto, apunta a null .
Aquí es donde la mayoría de la gente se confunde:
Cuando creas una nueva función en JavaScript (que también es un objeto, ¿recuerdas?), En el momento en que se define, JavaScript crea automáticamente una nueva propiedad en esa función llamada prototype . Intentalo:
var A = [];
A.prototype // undefined
A = function() {}
A.prototype // {} // got created when function() {} was defined
A.prototype es TOTALMENTE DIFERENTE de la propiedad __proto__ . En nuestro ejemplo, ''A'' ahora tiene DOS propiedades llamadas ''prototipo'' y __proto__ . Esta es una gran confusión para la gente. __proto__ propiedades prototype y __proto__ están relacionadas de ninguna manera, son cosas separadas que apuntan a valores separados.
Puede preguntarse: ¿Por qué JavaScript ha creado la propiedad __proto__ en cada objeto? Bueno, una palabra: delegación . Cuando llama a una propiedad en un objeto y el objeto no lo tiene, entonces JavaScript busca el objeto al que hace referencia __proto__ para ver si tal vez lo tenga. Si no lo tiene, mira la propiedad __proto__ ese objeto y así sucesivamente ... hasta que la cadena termina. De ahí el nombre de prototipo de cadena . Por supuesto, si __proto__ no apunta a un objeto y en su lugar apunta a null , buena suerte, JavaScript se da cuenta de eso y lo devolverá undefined para la propiedad.
También puede preguntarse, ¿por qué JavaScript crea una propiedad llamada prototype para una función cuando define la función? Debido a que trata de engañarlo, sí, engañe a usted que funciona como idiomas basados en clases.
Continuemos con nuestro ejemplo y creamos un "objeto" a partir de A :
var a1 = new A();
Algo sucedió en el fondo cuando sucedió esto. a1 es una variable ordinaria a la que se asignó un nuevo objeto vacío.
El hecho de que haya utilizado el operador new antes de una invocación de función A() hizo algo ADICIONAL en segundo plano. La new palabra clave creó un nuevo objeto que ahora hace referencia a1 y ese objeto está vacío. Esto es lo que sucede además:
Dijimos que en cada definición de función hay una nueva propiedad creada llamada prototype (a la que puede acceder, a diferencia de la propiedad __proto__ ) creada? Bueno, esa propiedad se está utilizando ahora.
Así que ahora estamos en el punto donde tenemos un objeto a1 vacío recién horneado. Dijimos que todos los objetos en JavaScript tienen una propiedad __proto__ interna que apunta a algo ( a1 también lo tiene), ya sea nulo u otro objeto. Lo que hace el new operador es que establece que la propiedad __proto__ apunta a la propiedad prototype la función. Lea eso otra vez. Es básicamente esto:
a1.__proto__ = A.prototype;
Dijimos que A.prototype no es más que un objeto vacío (a menos que lo cambiemos por otra cosa antes de definir a1 ). Entonces, básicamente, a1.__proto__ apunta a lo mismo que apunta el A.prototype , que es ese objeto vacío. Ambos apuntan al mismo objeto que se creó cuando ocurrió esta línea:
A = function() {} // JS: cool. let''s also create A.prototype pointing to empty {}
Ahora, hay otra cosa que sucede cuando se procesa var a1 = new A() . Básicamente se ejecuta A() y si A es algo como esto:
var A = function() { this.hey = function() { alert(''from A'') } };
Todas esas cosas dentro de la function() { } se ejecutarán. Cuando llegas a la línea this.hey.. , this cambia a a1 y obtienes esto:
a1.hey = function() { alert(''from A'') }
No explicaré por qué this cambia a a1 pero esta es una gran respuesta para obtener más información.
Entonces, para resumir, cuando haces `` var a1 = new A () `hay 3 cosas sucediendo en el fondo:
- Se crea un objeto vacío totalmente nuevo y se asigna a
a1.a1 = {} a1.__proto__propiedada1.__proto__se asigna para apuntar a lo mismo queA.prototypeapunta a (otro objeto vacío {})La función
A()se está ejecutando conthisconjunto en el nuevo objeto vacío creado en el paso 1 (lea la respuesta a la que hice referencia más arriba por quéthiscambia aa1)
Ahora, tratemos de crear otro objeto:
var a2 = new A();
Los pasos 1,2,3 se repetirán. ¿Notan algo? La palabra clave es repetir. Paso 1: a2 será un nuevo objeto vacío, paso 2: su propiedad __proto__ apuntará a lo mismo que apunta el A.prototype y, lo más importante, el paso 3: la función A() se ejecuta de nuevo, lo que significa que a2 obtendrá Propiedad que contiene una función. a1 y a2 tienen dos propiedades SEPARADAS llamadas hey que apuntan a 2 funciones SEPARADAS! Ahora tenemos funciones duplicadas en los mismos dos objetos diferentes que hacen lo mismo, oops ... Puedes imaginar las implicaciones de la memoria si tenemos 1000 objetos creados con la new A , después de que todas las declaraciones de funciones tomen más memoria que algo como el número 2 Entonces, ¿cómo podemos prevenir esto?
¿Recuerdas por qué existe la propiedad __proto__ en cada objeto? De modo que si recupera la propiedad yoMan en a1 (que no existe), se consultará su propiedad __proto__ , que si es un objeto (y en la mayoría de los casos lo es), verificará si contiene yoMan , y si no, consultará el __proto__ ese objeto, etc. Si lo hace, tomará el valor de esa propiedad y se lo mostrará.
Entonces, alguien decidió usar este hecho + el hecho de que cuando creas a1 , su propiedad __proto__ apunta al mismo objeto (vacío). A.prototype apunta y hace esto:
var A = function() {}
A.prototype.hey = function() { alert(''from prototype'') };
¡Guay! Ahora, cuando creas a1 , vuelve a pasar por los tres pasos anteriores, y en el paso 3, no hace nada, ya que la function A() no tiene nada que ejecutar. Y si lo hacemos:
a1.hey
Verá que a1 no contiene hey y verificará su objeto de propiedad __proto__ para ver si lo tiene, lo cual es el caso.
Con este enfoque, eliminamos la parte del paso 3 donde las funciones se duplican en cada creación de objeto nuevo. En lugar de que a1 y a2 tengan una propiedad hey separada, ahora ninguno de ellos la tiene. Lo cual, supongo, ya te diste cuenta. Eso es lo bueno ... si entiendes __proto__ y Function.prototype , preguntas como estas serán bastante obvias.
NOTA: Algunas personas tienden a no llamar la propiedad Prototipo interna como __proto__ , he usado este nombre en la publicación para distinguirlo claramente en la propiedad Functional.prototype como dos cosas diferentes.
Como se discutió en otras respuestas, es realmente una consideración de rendimiento porque la función en el prototipo se comparte con todas las instancias, en lugar de la función que se crea para cada instanciación.
Puse un jsperf para mostrar esto. Hay una diferencia dramática en el tiempo que se tarda en instanciar la clase, aunque en realidad solo es relevante si está haciendo muchas instancias.
Creo que @Matthew Crumley tiene razón. Son funcionalmente , si no estructuralmente, equivalentes. Si usa Firebug para mirar los objetos que se crean usando new, puede ver que son iguales. Sin embargo, mi preferencia sería la siguiente. Supongo que parece más bien a lo que estoy acostumbrado en C # / Java. Es decir, definir la clase, definir los campos, el constructor y los métodos.
var A = function() {};
A.prototype = {
_instance_var: 0,
initialize: function(v) { this._instance_var = v; },
x: function() { alert(this._instance_var); }
};
EDITAR No significaba que el alcance de la variable fuera privado, solo estaba tratando de ilustrar cómo definir mis clases en javascript. El nombre de la variable se ha cambiado para reflejar esto.
Piense en un lenguaje estático, las cosas prototypeson estáticas y las cosas thisestán relacionadas con la instancia.