Sabemos que en JS, no hay concepto de clase. Todos los objetos de instancia de una clase heredan atributos del mismo objeto prototipo, por lo que el objeto prototipo es el núcleo de la clase.
Una clase es una abstracción de un objeto, y un objeto es una instancia concreta de una clase. Las clases son abstractas y no ocupan memoria, mientras que los objetos son concretos y ocupan espacio de almacenamiento. --- Enciclopedia de Baidu
Los primeros requisitos de JavaScript fueron muy simples, básicamente escritos como funciones, seguidos de la escritura orientada al proceso. Más tarde, las ideas de desarrollo orientadas a objetos se introdujeron gradualmente, y luego se escribieron lentamente en clases.
En JS, la esencia de escribir en una clase es básicamente constructor + prototipo. A continuación, discutamos varias formas de escribir la clase JS:
Método de constructor
/*** Clase de persona: Defina una persona, con el atributo de nombre y el método GetName*/<script> Function Person (name) {this.name = name; this.getName = function () {return this.name; }} // Instanciamos varios objetos aquí var p1 = nueva persona ("trigkit4"); var p2 = nueva persona ("Mike"); console.log (P1 instanceof persona); // true console.log (P2 InstanceOf Person); // True </script>De la salida de la consola anterior, podemos ver que P1 y P2 son objetos de instancia de clase de persona. En el lado izquierdo de la instancia del operador está el objeto de la clase a detectar, y en el lado derecho está el constructor de la clase que define la clase. Aquí, InstanceOf se usa para detectar si el objeto P1 pertenece a la clase de persona.
La ventaja de este método es que podemos construir diferentes instancias de objetos de acuerdo con los parámetros. La desventaja es que cada vez que construimos el objeto de instancia, se generará el método GetName, lo que dará como resultado un desperdicio de memoria.
Podemos usar una función externa en lugar de métodos de clase, de modo que cada objeto comparta el mismo método. La clase reescrita es la siguiente:
// función externa <script> function getName () {return this.name; } function Person (nombre) {this.name = name; this.getName = getName; //} </script>Método prototipo
<script> function persona () {}; Persona.prototype.name = "trigkit4"; // Las propiedades de la clase se colocan en el prototipo persona.prototype.getName = function () {return "I'm" + this.name; } var p1 = nueva persona (); var p2 = nueva persona (); console.log (p1.name); // trigkit4 console.log (p2.getName ()); // soy trigkit4 </script>La desventaja del método prototipo es que la instancia del objeto no puede construirse a través de parámetros (generalmente las propiedades de cada objeto son diferentes). La ventaja es que todas las instancias de objetos comparten el método GetName (en relación con el método del constructor), y no hay residuos de memoria.
Constructor + Prototipo
Tome las ventajas de las dos primeras:
a. Use Constructor para definir los atributos de clase (campos).
b. Use prototipo para definir el método de clase.
<script> Function Person (name) {this.name = name; } // La función Prototype permite que las instancias de objetos compartan el método GetName persona.prototype.getName = function () {return "I'm" + this.name; } </script>De esta manera, podemos construir objetos con diferentes atributos y dejar que las instancias de objetos compartan métodos sin causar desechos de memoria.
Para que el código JS sea más compacto, movimos el código de método prototipo a los aparatos ortopédicos de la persona de funciones.
<script> Function Person (name) {this.name = name; Persona.prototype.getName = function () {name de return; // this.name no es adecuado}} var p1 = new Person ('trigkit4'); console.log (p1.getName ()); // trigkit4 </script>Aquí, necesitamos conocer varios métodos para definir clases, además del constructor anterior, también hay:
Método object.create ()
Con este método, una "clase" es un objeto, no una función.
var persona = {nombre: "trigkit4", edad: 21, run: function () {alert ("me gusta ejecutar"); }}Luego, use Object.Create () directamente para generar una instancia sin usar nuevo.
var p1 = object.create (persona); alerta (p1.age); // 21 p1.run (); // Me gusta correr
Este método es más simple que el "método de constructor", pero no puede implementar atributos privados y métodos privados, y los datos no pueden compartirse entre los objetos de instancia, por lo que la simulación de "clases" no es lo suficientemente integral.
método createenew ()
Este método no requiere esto y el prototipo. Es para usar objetos para simular una clase, luego definir un constructor createNew () en la clase y luego definir un objeto de instancia en createenew (), y use este objeto de instancia como el valor de retorno.
<script> var persona = {createenew: function () {var persona = {}; persona.name = "trigkit4"; persona.run = function () {alert ("me gusta ejecutar"); }; persona de regreso; }} </script>Cuando lo use, llame al método createenew () para obtener el objeto de instancia.
var p1 = persona.createNew (); p1.run (); // me gusta correr
Este método de escritura es en realidad muy similar al método de escritura de los literales de objetos, excepto que uno está separado por la coma y el otro está separado por el punto y coma.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.