Hay varias formas comunes de definir clases u objetos en JavaScript: enfoque de fábrica
función createCar(color, puertas, mpg){
var tempCar = nuevo objeto;
tempCar.color = color;
tempCar.puertas = puertas;
tempCar.mpg = mpg;
tempCar.showColor = función (){
alerta ( este .color);
};
devolver coche temporal;
}
var coche1 = createCar("rojo", 4, 23);
var coche2 = createCar("azul", 3, 25);
coche1.showColor();
coche2.showColor();
Se define una función de fábrica que puede crear y devolver objetos de un tipo específico. Se ve bien, pero hay un pequeño problema. Se debe crear una nueva función showColor cada vez que se llama. función mostrarColor(){ alerta(este.color); } Señalelo directamente en la función de fábrica. tempCar.showColor = mostrarColor; Esto evita el problema de crear funciones repetidamente, pero no parece un método de objeto. Modo constructor
función Coche(sColor, iDoors, iMpg){
este .color = sColor;
esto .puertas = iDoors;
este .mpg = iMpg;
este .showColor = función (){
alerta ( este .color);
};
}
var coche1 = coche nuevo ("rojo", 4, 23);
var coche2 = coche nuevo ("azul", 3, 25);
coche1.showColor();
coche2.showColor();
Puede ver la diferencia con el primer método. No se crea ningún objeto dentro del constructor, pero se utiliza esta palabra clave. Al llamar al constructor usando new, primero se crea un objeto y luego se accede a él usando this. Este uso es muy similar a otros lenguajes orientados a objetos, pero este método tiene el mismo problema que el anterior, que es crear funciones repetidamente. Un enfoque híbrido constructor/prototipo para la construcción
Este método consiste en utilizar el método constructor y el método prototipo al mismo tiempo. Combinando sus ventajas, el método constructor se introdujo anteriormente. función Coche(){
}
Car.prototype.color = "rojo";
Coche.prototipo.puertas = 4;
Coche.prototipo.mpg = 23;
Coche.prototipo.showColor = función (){
alerta ( este .color);
};
var coche1 = coche nuevo ();
var coche2 = coche nuevo ();
Primero, se define el constructor Car sin ningún código y luego se agregan las propiedades a través del prototipo. ventaja: a. Todas las instancias almacenan punteros a showColor, lo que resuelve el problema de crear funciones repetidamente. b. Puede utilizar instancia de para comprobar el tipo de objeto. alerta(coche1 instancia de Coche); Desventajas, agregue el siguiente código:
Car.prototype.drivers = new Array("mike", "demandar");
coche1.drivers.push("mate");
alert(car1.drivers); // genera "mike,sue,matt"
alert(car2.drivers); //genera "mike,sue,matt"
Los controladores son punteros a objetos Array y ambas instancias de Car apuntan a la misma matriz.
Usemos el siguiente método de mezcla: función Coche(sColor, iDoors, iMpg){
este .color = sColor;
esto .puertas = iDoors;
este .mpg = iMpg;
this .drivers = new Array("mike", "demandar");
}
Coche.prototipo.showColor = función (){
alerta ( este .color);
};
var coche1 = coche nuevo ("rojo", 4, 23);
var coche2 = coche nuevo ("azul", 3, 25);
coche1.drivers.push("mate");
alerta(coche1.conductores);
alerta(coche2.drivers);
De esta manera no hay problema y también puedes usar instancia de creación de prototipos dinámicos
función Coche(sColor, iDoors, iMpg){
este .color = sColor;
esto .puertas = iDoors;
este .mpg = iMpg;
this .drivers = new Array("mike", "demandar");
if ( tipo de coche.inicializado == "indefinido"){
Coche.prototipo.showColor = función (){
alerta ( este .color);
};
Coche.inicializado = verdadero ;
}
}
var coche1 = coche nuevo ("rojo", 4, 23);
var coche2 = coche nuevo ("azul", 3, 25);
coche1.drivers.push("mate");
alerta(coche1.conductores);
alerta(coche2.drivers);
Este método es mi favorito. Todas las definiciones de clases se completan en una función. Se parece mucho a las definiciones de clases en otros idiomas. Las funciones no se crearán repetidamente.
