Nous savons que dans JS, il n'y a pas de concept de classe. Tous les objets d'instance d'une classe Hérite d'attributs à partir du même objet Prototype, donc l'objet Prototype est le noyau de la classe.
Une classe est une abstraction d'un objet, et un objet est une instance concrète d'une classe. Les classes sont abstraites et n'occupent pas la mémoire, tandis que les objets sont en béton et occupent un espace de stockage. --- Encyclopédie Baidu
Les premières exigences JavaScript étaient très simples, essentiellement écrites en fonction, suivies d'une écriture axée sur le processus. Plus tard, les idées de développement orientées objet ont été progressivement introduites, puis elles ont été lentement écrites dans les classes.
Dans JS, l'essence de l'écriture dans une classe est essentiellement le constructeur + le prototype. Ci-dessous, discutons de plusieurs façons d'écrire la classe JS:
Méthode du constructeur
/ *** Classe de personne: définir une personne, avec nom d'attribut et méthode getName * / <script> function personne (name) {this.name = name; this.getName = function () {return this.name; }} // Nous instancons plusieurs objets ici var p1 = new personne ("Trigkit4"); var p2 = nouvelle personne ("Mike"); console.log (p1 instanceof personne); // true console.log (p2 instanceof personne); // true </ script>D'après la sortie de la console ci-dessus, nous pouvons voir que P1 et P2 sont en effet des objets d'instance de classe de personne. Sur le côté gauche de l'instance de l'opérateur est l'objet de la classe à détecter, et sur le côté droit se trouve le constructeur de la classe qui définit la classe. Ici, l'instance est utilisée pour détecter si l'objet P1 appartient à la classe de personne.
L'avantage de cette méthode est que nous pouvons construire différentes instances d'objet en fonction des paramètres. L'inconvénient est que chaque fois que nous construisons l'objet d'instance, la méthode GetName sera générée, ce qui entraîne des déchets de mémoire.
Nous pouvons utiliser une fonction externe au lieu de méthodes de classe, de sorte que chaque objet partage la même méthode. La classe réécrite est la suivante:
// fonction externe <Script> function getName () {return this.name; } fonction Person (name) {this.name = name; this.getName = getName; //} </ script>Méthode prototype
<Script> Fonction Person () {}; Personne.prototype.name = "Trigkit4"; // Les propriétés de la classe sont placées sur le prototype personne.prototype.getName = function () {return "je suis" + this.name; } var p1 = new personne (); var p2 = new personne (); console.log (p1.name); // Trigkit4 console.log (p2.GetName ()); // je suis trigkit4 </cript>L'inconvénient de la méthode du prototype est que l'instance d'objet ne peut pas être construite à travers des paramètres (généralement les propriétés de chaque objet sont différentes). L'avantage est que toutes les instances d'objet partagent la méthode GetName (par rapport à la méthode du constructeur) et qu'il n'y a pas de déchet de mémoire.
Constructeur + prototype
Prenez les avantages des deux premiers:
un. Utilisez le constructeur pour définir les attributs de classe (champs).
né Utilisez le prototype pour définir la méthode de classe.
<Script> Fonction Person (name) {this.name = name; } // La fonctionnalité Prototype permet aux instances d'objet de partager la méthode getName personne.prototype.getName = function () {return "je suis" + this.name; } </ script>De cette façon, nous pouvons construire des objets avec différents attributs et laisser les instances d'objet partager des méthodes sans provoquer de déchets de mémoire.
Afin de rendre le code JS plus compact, nous avons déplacé le code de méthode prototype dans les accolades de la personne.
<Script> Fonction Person (name) {this.name = name; Personne.prototype.getName = function () {Nom de retour; // this.name ne convient pas}} var p1 = new Person ('Trigkit4'); console.log (p1.getName ()); // Trigkit4 </cript>Ici, nous devons connaître plusieurs méthodes pour définir des classes, en plus du constructeur ci-dessus, il y a aussi:
Méthode object.create ()
Avec cette méthode, une "classe" est un objet, pas une fonction.
var personne = {name: "Trigkit4", âge: 21, exécuter: function () {alert ("j'aime courir"); }}Ensuite, utilisez Object.Create () directement pour générer une instance sans utiliser nouveau.
var p1 = object.create (personne); alert (p1.age); // 21 p1.run (); // j'aime courir
Cette méthode est plus simple que la "méthode du constructeur", mais elle ne peut pas implémenter des attributs privés et des méthodes privées, et les données ne peuvent pas être partagées entre les objets d'instance, de sorte que la simulation des "classes" n'est pas suffisamment complète.
Méthode CreateEnew ()
Cette méthode ne nécessite pas cela et le prototype. Il s'agit d'utiliser des objets pour simuler une classe, puis définir un constructeur CreateEnew () dans la classe, puis définir un objet d'instance dans createEnew (), et utiliser cet objet d'instance comme valeur de retour.
<Script> var person = {CreateEnew: function () {var person = {}; personne.name = "Trigkit4"; personne.run = function () {alert ("j'aime courir"); }; personne de retour; }} </ script>Lorsque vous l'utilisez, appelez la méthode CreateEnew () pour obtenir l'objet d'instance.
var p1 = personne.CreateEnew (); p1.run (); // j'aime courir
Cette méthode d'écriture est en fait très similaire à la méthode d'écriture des littéraux d'objets, sauf que l'une est séparée par la virgule et que l'autre est séparée par semi-colon.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.