Sabemos que JS está orientado a objetos. Cuando se trata de orientación de objetos, es inevitable involucrar el concepto de clases. En general, los idiomas fuertemente tipados como C# y Java tienen una sintaxis fija para definir clases. La diferencia entre JS es que puede usar varios métodos para implementar sus propias clases y objetos. Existen varios métodos de implementación general:
1. Método de fábrica
El método de fábrica se refiere a la creación de una función de fábrica que devuelve un tipo de objeto específico.
La copia del código es la siguiente:
function createCar (scolor, idoors, impg)
{
var otempcar = nuevo objeto;
otempcar.color = scolor;
otempcar.doors = idoors;
otempcar.mpg = impg;
otempcar.showColor = function ()
{
alerta (this.color);
}
regresar otempcar;
}
var ocar1 = createCar ("rojo", 4,23);
var oCar2 = createCar ("azul", 3,25);
Ocar1.showColor ();
Ocar2.showColor ();
De esta manera, cada vez que llama a su función de fábrica, se creará un nuevo objeto. Pero el problema es que cada vez que se genera un nuevo objeto, se debe crear una nueva función showcolor, lo que hace que cada objeto tenga su propia versión de showcolor y, de hecho, todos los objetos comparten la misma función. es el método del objeto se define fuera de la función de fábrica, y luego el objeto recibe un puntero a la función, de la siguiente manera
La copia del código es la siguiente:
función showcolor ()
{
alerta (this.color);
}
function createCar (scolor, idoors, impg)
{
var otempcar = nuevo objeto;
otempcar.color = scolor;
otempcar.doors = idoors;
otempcar.mpg = impg;
otempcar.showColor = showColor;
regresar otempcar;
}
var ocar1 = createCar ("rojo", 4,23);
var oCar2 = createCar ("azul", 3,25);
Ocar1.showColor ();
Ocar2.showColor ();
De esta manera, no es necesario crear su propia función showcolor para cada objeto, pero simplemente cree un puntero a esta función. Por lo tanto, se introduce el método del constructor.
2. Método del constructor
El constructor es muy similar a la función de fábrica, el código de ejemplo es el siguiente:
La copia del código es la siguiente:
Function Car (Scolor, Idoors, Impg)
{
this.color = scolor;
this.doors = idoors;
this.mpg = impg;
this.showColor = function ()
{
alerta (this.color);
}
}
var ocar1 = auto nuevo ("rojo", 4,23);
var oCar2 = auto nuevo ("azul", 3,25);
En el constructor, no hay objeto creado internamente, pero la palabra clave esto se usa. Al llamar al constructor utilizando el nuevo operador, se crea un objeto antes de ejecutar la primera línea de código. Pero, ¿qué problemas pasarán con esto? Para resolver este problema, se introdujo el siguiente método prototipo.
3. Método prototipo
Este método aprovecha la propiedad prototipo del objeto, que puede considerarse como el prototipo en el que depende un nuevo objeto. Aquí, use el constructor vacío para establecer el nombre de la clase. Entonces todos los métodos y atributos se asignan directamente al atributo prototipo. como sigue:
La copia del código es la siguiente:
function car ()
{}
Car.prototype.color = "rojo";
Car.prototype.doors = 4;
Car.prototype.mpg = 23;
Car.prototype.drivers = new Array ("Mike", "Sue");
Car.prototype.showColor = function ()
{
alerta (this.color);
}
El método prototipo solo puede asignar valores directamente y no puede pasar los parámetros al constructor el valor de la inicialización del atributo. Al usar este método, encontrará dos problemas. El primer problema es que cada objeto debe crearse antes de que el valor predeterminado del atributo se pueda cambiar de esta manera. No es posible tener directamente los valores de la propiedad que necesita al crear cada objeto. Esto es molesto. El segundo problema es cuando el atributo se refiere al objeto. No habrá problemas con el intercambio de funciones, pero habrá problemas con el intercambio de objetos. Porque cada instancia generalmente necesita implementar su propio objeto.
Como sigue:
La copia del código es la siguiente:
var oCar1 = nuevo coche ();
var oCar2 = nuevo coche ();
Ocar1.Drivers.push ("Matt");
alerta (OCAR1.Drivers); // Salida "Mike, Sue, Matt"
alerta (OCAR2.Drivers); // Salida "Mike, Sue, Matt"
Por lo tanto, el atributo de controladores es solo un puntero al objeto, por lo que todas las instancias realmente comparten el mismo objeto. Debido a estos problemas, presentamos el siguiente método de constructor de uso conjunto y prototipo.
4. Método de constructor/prototipo mixto
La idea de este método es usar un constructor para definir todas las propiedades no funcionales de un objeto (incluidas las propiedades y atributos ordinarios que apuntan al objeto) y usar un prototipo para definir las propiedades de la función (métodos) de un objeto. El resultado es que todas las funciones se crean solo una vez, y cada objeto tiene su propia instancia de atributo de objeto. El código de muestra es el siguiente:
La copia del código es la siguiente:
Function Car (Scolor, Idoors, Impg)
{
this.color = scolor;
this.doors = idoors;
this.mpg = impg;
this.drivers = new Array ("Mike", "Sue");
}
Car.prototype.showColor = function ()
{
alerta (this.color);
}
var ocar1 = auto nuevo ("rojo", 4,23);
var oCar2 = auto nuevo ("azul", 3,25);
Ocar1.Drivers.push ("Matt");
alerta (OCAR1.Drivers); // Salida "Mike, Sue, Matt"
alerta (OCAR2.Drivers); // Salida "Mike, Sue"
Como se puede ver en el código de ejemplo, este método resuelve dos problemas en el método anterior al mismo tiempo. Sin embargo, de esta manera, algunos desarrolladores todavía sienten que no es perfecto.
5. Método de prototipo dinámico
Podemos ver que la mayoría de los idiomas orientados a objetos encapsulan visualmente las propiedades y métodos. Sin embargo, el método showcolor en el método anterior se define fuera de la clase. Por lo tanto, diseñaron un enfoque prototipo dinámico. La idea básica de este enfoque es la misma que el enfoque de constructor/prototipo mixto, la única diferencia es la ubicación del método de objeto. Como se muestra a continuación:
La copia del código es la siguiente:
Function Car (Scolor, Idoors, Impg)
{
this.color = scolor;
this.doors = idoors;
this.mpg = impg;
this.drivers = new Array ("Mike", "Sue");
if (typeof car._initialized == "indefinido")
{
Car.prototype.showColor = function ()
{
alerta (this.color);
}
}
Coche._initialized = true;
}
De esta manera el auto.prototype.showColor se crea solo una vez. Esta dependencia hace que este código sea más como la definición de clase en otros idiomas.
6. Método de fábrica mixta
Este enfoque suele ser una solución que no se puede utilizar como enfoque anterior. Su propósito es crear un constructor falso que devuelva solo nuevas instancias de otro objeto.
La copia del código es la siguiente:
función createCar ()
{
var otempcar = nuevo objeto;
otempcar.color = "rojo";
otempcar.doors = 4;
otempcar.mpg = 23;
otempcar.showColor = function ()
{
alerta (this.color);
};
regresar otempcar;
}
var car = nuevo coche ();
Dado que el nuevo operador se llama Inside the Car () Constructor, el segundo nuevo operador se ignora automáticamente. Los objetos creados dentro del constructor se vuelven a pasar a la variable var. Este enfoque tiene los mismos problemas que el enfoque clásico en términos de gestión interna de los métodos de objetos. Por lo tanto, es muy recomendable: evite usar este método a menos que sea absolutamente necesario.