En JavaScript, la clase se puede usar para implementar la programación orientada a objetos. Sin embargo, las clases en JavaScript son diferentes de las de Java, y sus definiciones y usos correspondientes también son diferentes.
Definición de clases en JavaScript
En JavaScript, todos los objetos derivados del mismo objeto prototipo (prototipo) forman una clase; Es decir, las clases en JavaScript son conceptos de una colección de objetos. Si dos objetos tienen el mismo prototipo, pertenecen a la misma clase; Las clases en JavaScript ni siquiera necesitan nombres de clases. El siguiente código es un ejemplo:
La copia del código es la siguiente:
var p = {x: 42};
var a = object.create (p);
var b = object.create (p);
console.log (a === b); // falso
console.log (object.getPrototypeOf (a) === Object.getPrototypeOf (b)); // True
En el ejemplo anterior, los objetos A y B tienen el mismo objeto prototipo (prototipo) P, por lo que A y B pertenecen a la misma clase (aunque ninguna de esta clase tiene un nombre de clase), y heredan la propiedad x con un valor de 42 del objeto prototipo p.
A partir de este ejemplo, podemos ver que la función de un objeto prototipo es equivalente a una plantilla, y se pueden derivar/crear múltiples objetos a partir de él. Su estado es el mismo que el del código de clase en el idioma Java y es el núcleo de la definición de clase en JavaScript. El objeto prototipo en el siguiente ejemplo aparecerá más como el código de clase:
La copia del código es la siguiente:
var p = {
Increment_by: 1,
incremento: función (x) {
return x + this.increment_by;
}
}
var a = object.create (p);
var b = object.create (p);
console.log (A.Increment (7)); // 8
console.log (B.Increment (9)); // 10
En el ejemplo anterior, el objeto prototipo P define una propiedad (increment_by) con un valor de 1 y una función llamada incremento; Los objetos A y B obtienen las funciones incrementales y de incremento de la plantilla p. Al llamar a la función de incremento del objeto A o B, JavaScript intentará obtener el valor incremento de A o B (this.increment_by); Dado que increment_by se obtiene de P, sus valores son todos 1 - variables con los mismos valores, similares a las variables de clase estática en Java. Por lo tanto, en el ejemplo anterior, todos los caracteres de capital se usan al nombrar la variable increment_by.
En el ejemplo anterior, todos los objetos creados a partir de la plantilla P (los objetos que pertenecen a la misma clase) tienen las mismas propiedades y comportamientos. Pero de hecho, para diferentes objetos de la misma clase, además de tener atributos/comportamientos definidos por la clase, a menudo tienen algunos atributos y comportamientos únicos. Por lo tanto, si necesita usar la plantilla de prototipo como clase, debe personalizar cada objeto derivado de él:
La copia del código es la siguiente:
var p = {
Increment_by: 1,
incremento: función (x) {
return x + this.increment_by + this.custom_increment_by;
}
}
var a = object.create (p);
var b = object.create (p);
a.custom_incement_by = 0;
b.custom_incement_by = 1;
console.log (A.Increment (7)); // 8
console.log (B.Increment (9)); // 11
En este ejemplo, los objetos A y B creados a partir de la plantilla P tienen una variable Custom_incement_By cuyos valores no son necesariamente iguales entre sí, y el resultado final de su comportamiento de función increment () está relacionado con el valor de Custom_increment_By. En términos generales, el trabajo de personalizar nuevos objetos a menudo se lleva a cabo en una función unificada:
La copia del código es la siguiente:
var p = {
Increment_by: 1,
incremento: función (x) {
return x + this.increment_by + this.custom_increment_by;
}
}
función getIncrementClassObject (CustomIncrementByValue) {
var incrementAlObj = object.create (p);
incrementAlObj.custom_incement_by = CustomIncrementByValue;
devolver incrementalobj;
}
var a = getIncrementClassObject (0);
var b = getIncrementClassObject (1);
console.log (A.Increment (7)); // 8
console.log (B.Increment (9)); // 11
De esta manera, una definición de clase se completa a través del objeto prototipo P y las funciones GetIncrementalClassObject (): los objetos prototipo cuyos objetos prototipo son P se pueden obtener llamando a la función getIncrementClassObject (), y estos nuevos objetos se pueden personalizar en cierta medida durante la llamada a la función GetCrementalClassOnsobject (). Vale la pena señalar que esta clase definida no tiene un nombre de clase en este momento. En aras de la descripción, se llamará incremental.
Mirando hacia atrás en el trabajo realizado en la función GetIncrementClassObject (), puede ver que el proceso de crear un nuevo objeto a partir de la clase incremental es el siguiente:
1. Cree un objeto vacío y defina su objeto prototipo como p.
2. Personalice este objeto vacío recién creado de acuerdo con diferentes valores de parámetros.
3. Devuelva un nuevo objeto que haya sido personalizado.
En JavaScript, puede completar rápidamente la definición de la clase y la creación de nuevos objetos utilizando el constructor.
Constructor (Constructor) en JavaScript
Del ejemplo de la clase incremental anterior, podemos ver que definir una nueva clase requiere dos partes de código: crear un objeto prototipo como plantilla, creando una función personalizada para inicializar el nuevo objeto; La creación de un nuevo objeto a partir de una clase pasa por tres procesos: especificar el objeto prototipo del nuevo objeto, personalizar/inicializar el nuevo objeto y devolver este nuevo objeto. En JavaScript, todo esto se puede hacer a través del constructor (constructor).
El constructor en JavaScript es una función que asume la responsabilidad de inicializar un nuevo objeto; El prototipo de esta función de constructor se usa como una plantilla para crear un nuevo objeto. Tomando la clase incremental anterior como ejemplo, después de usar el constructor para reescribir el código, parece esto:
La copia del código es la siguiente:
función incremental (CustomIncrementByValue) {
this.custom_incement_by = CustomIncrementByValue;
}
Incremental.prototype = {
Increment_by: 1,
incremento: función (x) {
return x + this.increment_by + this.custom_increment_by;
}
}
var a = nuevo incremental (0);
var b = nuevo incremental (1);
console.log (A.Increment (7)); // 8
console.log (B.Increment (9)); // 11
El proceso de crear un nuevo objeto utilizando la función Constructor a través de la nueva palabra clave en realidad pasa por las siguientes etapas:
Crea un nuevo objeto vacío.
1. Apunte el objeto prototipo de este objeto a la propiedad prototipo de la función del constructor.
2. Use este objeto como este parámetro y ejecute la función de constructor.
3. Esto es lo mismo que el trabajo anterior realizado en la función getincincrementClassObject ().
Nombre de clase
Al crear un objeto usando el constructor, el objeto correspondiente tiene un "nombre de clase", que se puede verificar a partir del resultado de la instancia de operador:
La copia del código es la siguiente:
console.log (una instancia de incremental); // Verdadero
console.log (b instancia de incremental); // Verdadero
Sin embargo, la instancia del operador no determina si el objeto es creado por el constructor incremental. La instancia del operador solo determina si el objeto prototipo del objeto es incremental.prototype. Cuando hay dos constructores con el mismo prototipo, la instancia del operador devolverá verdadero uniformemente sin distinguir qué constructor se usa para crear el objeto.
La copia del código es la siguiente:
función incremental2 (CustomIncrementByValue) {
this.custom_increment_by = CustomIncrementByValue + 3;
}
Incremental2.prototype = incremental.prototype;
console.log (una instancia de incremental2); // Verdadero