Hay muchas formas de definir clases en JS:
1. Método de fábrica
La copia del código es la siguiente:
function car () {
var oCar = nuevo objeto;
Ocar.color = "Blue";
OCAR.Doors = 4;
Ocar.showColor = function () {
document.write (this.color)
};
devolver OCAR;
}
var car1 = car ();
var car2 = car ();
Cuando se llama a esta función, se crea un nuevo objeto y se asignan todas las propiedades y métodos. Use esta función para crear 2 objetos con exactamente las mismas propiedades. Por supuesto, mi hermana puede modificar este método pasando parámetros.
La copia del código es la siguiente:
function car (color, puerta) {
var oCar = nuevo objeto;
OCAR.Color = Color;
OCAR.Doors = puerta;
Ocar.showColor = function () {
document.write (this.color)
};
devolver OCAR;
}
var car1 = car ("rojo", 4);
var car2 = car ("azul", 4);
Car1.showColor () // Salida: "Rojo"
Car2.showColor () // Salida: "Azul"
Ahora puede obtener objetos con diferentes valores pasando diferentes parámetros a la función.
En el ejemplo anterior, cada vez que se llama la función Car (), showColor () se crea, lo que significa que cada objeto tiene su propio método showcolor ().
Pero, de hecho, cada objeto comparte la misma función.
Aunque un método se puede definir fuera de la función, luego señalando las propiedades de la función al método.
La copia del código es la siguiente:
función showColor () {
alerta (this.color);
}
function car () {
var oCar = new Object ();
OCAR.Color = Color;
OCAR.Doors = puerta;
Ocar.ShowColor = showColor;
devolver OCAR;
}
Pero esto no parece un método de función.
2. Método del constructor
El método del constructor es tan simple como el método de fábrica, como se muestra a continuación:
La copia del código es la siguiente:
function car (color, puerta) {
this.color = color;
this.Doors = puerta;
this.showColor = function () {
alerta (this.color)
};
}
var car1 = coche nuevo ("rojo", 4);
var car2 = auto nuevo ("azul", 4);
Puede ver que el método del constructor no crea objetos dentro de la función, y la palabra clave se utiliza. Porque se ha creado un objeto al llamar al constructor, y esto solo se puede usar para acceder a las propiedades del objeto dentro de la función.
Ahora usando nuevos para crear objetos, ¡se ve así! Pero es lo mismo que la fábrica. Cada llamada crea su propio método para el objeto.
3. Método prototipo
Este método aprovecha el atributo prototipo del objeto. Primero, cree el nombre de clase con una función vacía, y luego todos los atributos y métodos se asignan al atributo prototipo.
La copia del código es la siguiente:
function car () {
}
Car.prototype.color = "rojo";
Car.prototype.doors = 4;
Car.prototype.showColor = function () {
alerta (this.color);
}
var car1 = nuevo coche ();
var car2 = nuevo coche ();
En este código, primero se define una función vacía, y luego las propiedades del objeto se definen a través del atributo prototipo. Cuando se llama a esta función, todas las propiedades del prototipo se asignarán al objeto que se creará de inmediato. Todos los objetos en esta función almacenan punteros para showcolor (), que sin sintácticamente parece pertenecer al mismo objeto.
Sin embargo, esta función no tiene parámetros, y el atributo no se puede inicializar mediante parámetros de aprobación. El valor predeterminado del atributo debe cambiarse después de crear el objeto.
Un problema muy grave con el método prototipo es que cuando el atributo apunta a un objeto, como una matriz.
La copia del código es la siguiente:
function car () {
}
Car.prototype.color = "rojo";
Car.prototype.doors = 4;
Car.prototype.arr = new Array ("A", "B");
Car.prototype.showColor = function () {
alerta (this.color);
}
var car1 = nuevo coche ();
var car2 = nuevo coche ();
car1.arr.push ("cc");
alerta (coche1.arr); // Salida: AA, BB, CC
alerta (car2.arr); // Salida: AA, BB, CC
Aquí, debido al valor de referencia de la matriz, ambos objetos del automóvil apuntan a la misma matriz, por lo que cuando el valor se agrega en CAR1, también puede verlo en CAR2.
Union es un método que puede crear objetos como otros lenguajes de programación utilizando constructor/prototipo. Es un método que utiliza constructores para definir propiedades no funcionales de los objetos y utiliza prototipos para definir objetos.
La copia del código es la siguiente:
function car (color, puerta) {
this.color = color;
this.Doors = puerta;
this.arr = new Array ("aa", "bb");
}
Car.prototype.showColor () {
alerta (this.color);
}
var car1 = coche nuevo ("rojo", 4);
var car2 = auto nuevo ("azul", 4);
car1.arr.push ("cc");
alerta (coche1.arr); // Salida: AA, BB, CC
alerta (car2.arr); // Salida: AA, BB
5. Método de prototipo dinámico
El método de prototipo dinámico es similar al método de constructor/prototipo mixto. La única diferencia es la posición dada al método del objeto.
La copia del código es la siguiente:
function car (color, puerta) {
this.color = color;
this.Doors = puerta;
this.arr = new Array ("aa", "bb");
if (typeof car._initialized == "indefinido") {
Car.prototype.showColor = function () {
alerta (this.color);
};
Coche._initialized = true;
}
}
El método de prototipo dinámico es usar un indicador para determinar si al prototipo se le ha asignado un método. Esto asegura que el método se cree solo una vez
6. Método de fábrica mixta
Su maestro de propósito crea un constructor falso que devuelve solo nuevas instancias de otro objeto.
La copia del código es la siguiente:
function car () {
var oCar = new Object ();
Ocar.color = "rojo";
OCAR.Doors = 4;
Ocar.showColor = function () {
alerta (this.color)
};
devolver OCAR;
}
A diferencia del método de fábrica, este método utiliza el nuevo operador.
Los anteriores son todos los métodos para crear objetos. El método más utilizado es el método híbrido constructor/prototipo, y el método de prototipo dinámico también es muy popular. Funcionalmente equivalente al método constructor/prototipo.
Lo anterior se trata de este artículo, espero que les guste.