Hay muchas formas de crear objetos en JavaScript.
Constructor de objeto/objeto literal :
Dejando de lado el patrón de diseño, el método más básico es llamar primero al constructor de objeto para crear un objeto y luego agregar atributos al objeto.
La copia del código es la siguiente:
Var estudiante = nuevo objeto ();
student.name = "Xiao Ming";
estudiante.age = 20;
student.getName = function () {
alerta (this.name);
}
Los estudiantes que están familiarizados con el objeto literal de JavaScript pueden cambiar a una mejor manera de escribir, al menos parece más conciso.
La copia del código es la siguiente:
estudiante var = {
Nombre: "Xiao Hong",
Edad: 18,
getName: function () {
alerta (this.name);
}
};
Desventajas: una de las desventajas del método anterior es que cuando se usa la misma interfaz para crear muchos objetos similares, se generará una gran cantidad de código duplicado. Esto debería ser fácil de entender. Las funciones (métodos o clases) generalmente se utilizan para crear métodos públicos. El proceso de creación de objetos anterior no tiene ninguna sombra de funciones, por lo que no hay reutilización.
Modo de fábrica :
El patrón de fábrica abstrae el proceso de crear un objeto concreto. Al igual que una caja negra, solo necesita llamar a la función (ingrese la fábrica) y pasar en los parámetros correspondientes (varias materias primas), y saldrá un objeto correspondiente (producto producido por la fábrica). El patrón de fábrica resuelve el problema de crear múltiples objetos similares.
La copia del código es la siguiente:
function studentFactory (nombre, edad) {
Var estudiante = nuevo objeto ();
student.name = nombre;
estudiante.age = edad;
student.sayname = function () {
alerta (this.name);
}
Estudiante de regreso;
}
var p1 = studentFactory ("ming", 20);
var p2 = StudentFactory ("Hong", 18);
Desventajas: el patrón de fábrica también tiene sus desventajas, y la mayor desventaja es el problema del reconocimiento del tipo de objeto. Solo se puede determinar que el objeto es de tipo de objeto (instancia p1 de objeto), pero es imposible determinar qué tipo es. Los estudiantes creados utilizando el modo de fábrica en realidad tienen propiedades y métodos similares, pero los valores son diferentes. Una mejor solución en este momento es crear una función de estudiante para que todos los objetos pertenezcan al tipo de estudiante. Entonces, el modo de fábrica no es malo, pero el modo constructor es mejor.
Constructor de tipo personalizado:
Los constructores se pueden usar para crear objetos de un tipo específico.
La copia del código es la siguiente:
Function Student (nombre, edad) {
this.name = name;
this.age = edad;
this.sayName = function () {
alerta (this.name);
}
}
var p3 = nuevo estudiante ("Ming", 20);
var p4 = nuevo estudiante ("Hong", 18);
alerta (instancia p3 de estudiante);
alerta (p3.sayname == p4.sayname); //FALSO
Desventajas: la desventaja de los constructores personalizados es que cada objeto recreará su propio método. De hecho, estos métodos tienen la misma función (como SayName), pero no son los mismos (p3.sayname y p4.sayname no son iguales).
Modo prototipo:
Defina una función vacía y agregue todas las propiedades y métodos al prototipo para que todos los objetos compartan estas propiedades y métodos.
La copia del código es la siguiente:
function student () {};
Student.prototype.name = "ming";
Student.prototype.age = 20;
Student.prototype.friends = ['Qi'];
Student.prototype.sayname = function () {
alerta (this.name);
};
Desventajas: algunos atributos no se pueden compartir, y compartirlos trae problemas, como: amigos. La mayoría de los amigos de cada estudiante no serán lo mismo.
Combinación de constructor y prototipo:
La copia del código es la siguiente:
Function Student (nombre, edad, amigos) {
this.name = name;
this.age = edad;
this.friends = Friends;
}
Student.prototype = {
Constructor: Estudiante,
sayname: function () {
alerta (this.name);
}
};
Resumen: La combinación de constructores y prototipos es un método ampliamente reconocido para crear tipos personalizados. También es el mejor método entre los métodos anteriores.
/****************************************************************************************************
De hecho, ya hay muchos métodos para crear objetos anteriores, pero todavía hay algunos escenarios especiales que requieren una optimización continua.
Modo prototipo dinámico:
Es una optimización de la combinación de constructores y prototipos. Para esos atributos y métodos comunes, si se inicializan, no es necesario repetir la inicialización para mejorar la eficiencia.
La copia del código es la siguiente:
Function Student (nombre, edad) {
this.name = name;
this.age = edad;
if ((typeof this.sayname)! = "función") {
Student.prototype.sayname = function () {
alerta (this.name);
}
}
}
var stu = nueva persona ("Ming", 20);
// alerta (instancia stu de alumno);
stu.sayname ();
var stunew = nueva persona ("Hong", 18);
// alerta (instancia de Stunew de estudiante);
stunew.sayname ();
Cuando se crean múltiples objetos de alumnos, el método SayName se inicializa solo una vez.
Finalmente, hay otra forma muy útil de crear objetos, que es construir de forma segura las funciones.
Patrón de constructor estable:
Esto y lo nuevo están prohibidos en este modo, y todos los objetos no tienen atributos públicos. Solo se lee el valor de la variable, pero no se modifica.
La copia del código es la siguiente:
//// Modo de constructor STAFE
Function Student (nombre, edad) {
var o = nuevo objeto ();
O.SayName = function () {
alerta (nombre);
}
regreso o;
}
var stu = estudiante ("ming", 21);
stu.sayname ();
Lo anterior resume varios métodos de JavaScript comunes para crear objetos personalizados, que son muy completos. Si tiene otros mejores, contácteme. Este artículo continúa actualizándose.