introducir
Todos están familiarizados con los constructores, pero si usted es un novato, todavía es necesario comprender qué son los constructores. El constructor se usa para crear un tipo específico de objeto: no solo declara el objeto utilizado, sino que también acepta parámetros para establecer el valor del miembro del objeto cuando el objeto se crea por primera vez. Puede personalizar su propio constructor y declarar las propiedades o métodos del objeto de tipo personalizado.
Uso básico
En JavaScript, los constructores generalmente se consideran para implementar instancias. JavaScript no tiene el concepto de clases, sino que tiene constructores especiales. Use la nueva palabra clave para llamar a la función temprana definida. Puede decirle a JavaScript que desea crear un nuevo objeto y que las declaraciones de miembros del nuevo objeto se definen en el constructor. Dentro del constructor, esta palabra clave se refiere al objeto recién creado. El uso básico es el siguiente:
La copia del código es la siguiente:
function car (modelo, año, millas) {
this.model = modelo;
this.Year = año;
this.miles = millas;
this.output = function () {
devuelve este.model + "izquierda" + this.miles + "km";
};
}
var tom = auto nuevo ("tío", 2009, 20000);
var dudu = auto nuevo ("dudu", 2010, 5000);
console.log (tom.output ());
console.log (dudu.output ());
El ejemplo anterior es un patrón de constructor muy simple, pero es un poco un problema. En primer lugar, es muy problemático usar la herencia. En segundo lugar, la salida () se redefine cada vez que se crea un objeto. La mejor manera es dejar que todas las instancias de tipo de automóvil compartan este método de salida (), de modo que si hay grandes lotes de instancias, ahorrará mucha memoria.
Para resolver este problema, podemos usar el siguiente método:
La copia del código es la siguiente:
function car (modelo, año, millas) {
this.model = modelo;
this.Year = año;
this.miles = millas;
this.output = formatcar;
}
función formatcar () {
devuelve este.model + "izquierda" + this.miles + "km";
}
Aunque este método está disponible, tenemos el siguiente método mejor.
Constructores y prototipos
Hay una propiedad prototipo en JavaScript llamada prototipo. Cuando se llama al constructor para crear un objeto, todas las propiedades del prototipo del constructor están disponibles en el objeto recién creado. De esta manera, múltiples instancias de objetos de automóvil pueden compartir el mismo prototipo. Expandamos el código en el ejemplo anterior:
La copia del código es la siguiente:
function car (modelo, año, millas) {
this.model = modelo;
this.Year = año;
this.miles = millas;
}
/*
Nota: Aquí utilizamos el objeto.prototype. Nombre del método, no el objeto.prototype
Se usa principalmente para evitar reescribir el objeto prototipo prototipo
*/
Car.prototype.output = function () {
devuelve este.model + "izquierda" + this.miles + "km";
};
var tom = auto nuevo ("tío", 2009, 20000);
var dudu = auto nuevo ("dudu", 2010, 5000);
console.log (tom.output ());
console.log (dudu.output ());
Aquí, la instancia única de salida () se puede compartir y utilizar en todas las instancias de objetos para automóviles.
Además: recomendamos que los constructores comiencen con letras mayúsculas para distinguir las funciones ordinarias.
¿Puedes usar solo nuevo?
En el ejemplo anterior, el automóvil de funciones se crea usando nuevos objetos para crear. ¿Hay solo una forma? De hecho, hay otras formas, enumeremos dos:
La copia del código es la siguiente:
function car (modelo, año, millas) {
this.model = modelo;
this.Year = año;
this.miles = millas;
// Personalizar una salida de salida
this.output = function () {
devuelve este.model + "izquierda" + this.miles + "km";
}
}
// Método 1: llamado como una función
Coche ("tío", 2009, 20000); // Agregar al objeto de la ventana
console.log (window.output ());
// Método 2: llame al alcance de otro objeto
var o = nuevo objeto ();
Car.call (o, "Dudu", 2010, 5000);
console.log (o.output ());
El método 1 de este código es un poco especial. Si la nueva llama directamente la función, esto apunta a la ventana de objeto global. Verifiquemos:
La copia del código es la siguiente:
// Llamada de una función
var tom = car ("tío", 2009, 20000);
console.log (typeOf Tom); // "indefinido"
console.log (window.output ()); // "El tío caminó 20,000 kilómetros"
En este momento, el objeto Tom está indefinido, y Window.output () generará el resultado correctamente. Si usa la nueva palabra clave, no existe tal problema. La verificación es la siguiente:
La copia del código es la siguiente:
// Usar nueva palabra clave
var tom = auto nuevo ("tío", 2009, 20000);
console.log (typeOf Tom); // "objeto"
console.log (tom.output ()); // "El tío caminó 20,000 kilómetros"
Forzar nuevo
El ejemplo anterior muestra el problema de no usar nuevo. Entonces, ¿hay alguna forma de que el constructor forzara la nueva palabra clave? La respuesta es sí, código anterior:
La copia del código es la siguiente:
function car (modelo, año, millas) {
if (! (esta instancia de coche)) {
regresar nuevo auto (modelo, año, millas);
}
this.model = modelo;
this.Year = año;
this.miles = millas;
this.output = function () {
devuelve este.model + "izquierda" + this.miles + "km";
}
}
var tom = auto nuevo ("tío", 2009, 20000);
var dudu = car ("dudu", 2010, 5000);
console.log (typeOf Tom); // "objeto"
console.log (tom.output ()); // "El tío caminó 20,000 kilómetros"
console.log (typeOf dudu); // "objeto"
console.log (dudu.output ()); // "Dudu caminó 5000 kilómetros"
Al juzgar si esta instancia de es automóvil, decidimos devolver un auto nuevo o continuar ejecutando el código. Si se usa la nueva palabra clave, (esta instancia de automóvil) es verdadera y la siguiente asignación de parámetros continuará. Si no se usa nuevo, (esta instancia de automóvil) es falsa y se devolverá una nueva instancia.
Función de envoltura original
Hay 3 funciones de envoltorio originales en JavaScript: número, cadena, booleano, a veces se usan ambas:
La copia del código es la siguiente:
// Use la función de envoltorio original
var s = nueva cadena ("mi cadena");
var n = nuevo número (101);
var b = nuevo booleano (verdadero);
// Recomendar esto
var s = "mi cadena";
var n = 101;
var b = verdadero;
Recomendado, solo use estas funciones de envoltura cuando desee preservar el estado numérico. Para la diferencia, puede consultar el siguiente código:
La copia del código es la siguiente:
// cadena original
var greet = "Hola";
// usa el método Split () para dividir
salud.split ('') [0]; // "Hola"
// Agregar nuevos atributos al tipo original no informará un error
salud.smile = verdadero;
// Este valor no se puede obtener (hablamos sobre por qué en la implementación del Capítulo 18 ECMAScript)
console.log (typeof greet.smile); // "indefinido"
// cadena original
var salud = nueva cadena ("hola");
// usa el método Split () para dividir
salud.split ('') [0]; // "Hola"
// Agregar nuevos atributos al tipo de función de contenedor no informará un error
salud.smile = verdadero;
// se pueden acceder normalmente a nuevas propiedades
console.log (typeof greet.smile); // "booleano"
Resumir
Este capítulo explica principalmente las diferencias entre el uso del modo de constructor, el método de llamada y la nueva palabra clave. Espero que todos le presten atención al usarlo.
Referencia: http://www.addyosmani.com/resources/essentialjsdesignpatterns/book/#constructorpatternjavaScript