Explication détaillée de plusieurs méthodes différentes de création d'objets dans les compétences JS_javascript

Cet article présente plusieurs méthodes de création d'objets en js et les partage avec vous pour votre référence. Le contenu spécifique est le suivant

1. Mode usine

Inconvénients : Cela ne résout pas le problème de la reconnaissance des objets, c'est-à-dire comment connaître le type d'un objet.

2. Modèle de constructeur

Par rapport au mode usine :
1. Pas de création d'objet explicite
2. Attribuez directement des propriétés et des méthodes à cet objet
3. Aucune déclaration de retour
Pour créer une instance de personne, vous devez utiliser l'opérateur new. Appeler le constructeur de cette manière passe en fait par 4 étapes :
. 1. Créez un nouvel objet
2. Attribuez la portée du constructeur au nouvel objet
3. Exécutez le code dans le constructeur
4. Renvoyez le nouvel objet
Créez un constructeur personnalisé pour identifier son instance en tant que type spécifique.
Inconvénients du constructeur :
Chaque méthode est recréée sur chaque instance. person1 et person2 ont tous deux une méthode sayName(), mais les deux méthodes ne sont pas la même instance Function. Les fonctions portant le même nom sur différentes instances ne sont pas égales.
Il n'est pas nécessaire de créer deux instances de Function qui accomplissent la même tâche, et cet objet existe toujours. Il n'est pas nécessaire de lier la fonction à un objet spécifique avant d'exécuter le code, comme indiqué ci-dessous.

Définissez l'attribut sayName sur la fonction globale sayName. De cette façon, puisque sayName contient un pointeur vers une fonction, les objets person1 et person2 partagent la même fonction.
Toutefois, si l'objet doit définir de nombreuses méthodes, de nombreuses fonctions globales doivent être définies et il n'y a pas d'encapsulation de types de référence personnalisés. Afin de résoudre les problèmes ci-dessus, le mode prototype est introduit.

3. Mode prototype

Comprendre les objets prototypes
Chaque fonction que nous créons possède un attribut prototype, qui est un pointeur vers un objet, et le but de cet objet est de contenir des propriétés et des méthodes qui peuvent être partagées par toutes les instances d'un type spécifique. Le prototype est le prototype de l'instance d'objet créée en appelant le constructeur. L'avantage d'utiliser un objet prototype est que toutes les instances d'objet peuvent partager les propriétés et les méthodes qu'il contient.

Tout d'abord, l'analyseur demandera à l'instance person1 si elle a un attribut name, et si c'est le cas, il le renverra.
Sinon, continuez à rechercher l'attribut name dans le prototype de person1 et revenez s'il y en a un.
Sinon, continuez la recherche dans le prototype du prototype de person1.

isPrototypeOf() détermine l'association entre l'instance et l'objet prototype
console.log(Person.prototype.isPrototypeOf(person1)); //true
Object.getPrototypeOf() renvoie la valeur de [[prototype]]
console.log(Object.getPrototypeOf(person1));
//Person {nom : « Yvette », âge : 26, métier : « ingénieur »} renvoie l'objet prototype de Personne.
console.log(Object.getPrototypeOf(person1) === Person.prototype)//true
console.log(Object.getPrototypeOf(person1).name);//"Yvette"
La méthode hasOwnProperty() peut détecter si une propriété existe dans l'instance ou dans le prototype. Elle ne retournera vrai que si la propriété donnée existe dans l'instance.
console.log(person1.hasOwnProperty(“name”));//false
Prototype et en opérateur
Il existe deux manières d'utiliser l'opérateur in : seul et dans une boucle for-in. Lorsqu'il est utilisé seul, l'opérateur in renvoie true si la propriété donnée est accessible via l'objet, que la propriété réside dans l'instance ou dans le prototype.
À l'aide d'une boucle for in, toutes les propriétés énumérables accessibles via l'objet sont renvoyées, y compris les propriétés de l'instance et les propriétés qui existent dans le prototype. Ceci sera également renvoyé si une propriété de l'instance masque une propriété non énumérable dans le prototype. Il y a un bug dans l'implémentation des versions antérieures à IE9. Les attributs d'instance qui masquent les attributs non énumérables ne seront pas renvoyés dans le for-in.

Il n'y a aucune information de journal dans le bouton avant IE9. Bien que la méthode toString() dans l'instance de personne bloque le toString() non énumérable dans le prototype
Abréviation du prototype

Cela fait que person1.constructor ne pointe plus vers Person, mais vers Object. Si le constructeur est important, vous devez le définir spécifiquement sur une valeur appropriée, telle que :

Mais cette approche fera que la propriété constructeur deviendra énumérable.
Si vous souhaitez le définir comme non énumérable (la valeur par défaut n'est pas énumérable), vous pouvez utiliser Object.defineProperty(Person.prototype, "constructor", {
énumérable : faux,
valeur : Personne
});
Nature dynamique du prototype
Étant donné que le processus de recherche d'une valeur dans le prototype est une recherche, toutes les modifications que nous apportons à l'objet prototype sont immédiatement répercutées sur l'instance.
La situation est différente si l’intégralité de l’objet prototype est remplacée. Lorsque le constructeur est appelé, un pointeur [[prototype]] vers le prototype d'origine est ajouté à l'instance, et modifier le prototype en un autre objet équivaut à couper la connexion entre le constructeur et le prototype d'origine. Le pointeur dans l'instance pointe uniquement vers le prototype, pas vers le constructeur.

person.prototype pointe vers l'objet prototype d'origine et ne pointe pas vers le nouvel objet prototype.
Problèmes avec les objets prototypes
Le plus gros problème du modèle prototype réside dans sa nature partagée.
Le problème est plus important pour les propriétés contenant des valeurs de type référence

L'intention initiale était de modifier les amis de la personne 1, mais cela a également entraîné un changement de la valeur de l'attribut amis de la personne 2. C’est pourquoi nous utilisons rarement le modèle prototype seul.

4. Combinez le mode construction et le mode prototype

La manière la plus courante de créer des types personnalisés consiste à utiliser une combinaison de modèle de constructeur et de modèle de prototype. Le modèle de constructeur est utilisé pour définir les propriétés de l'instance et le modèle de prototype est utilisé pour définir les méthodes et les propriétés partagées. De cette manière, chaque instance possède sa propre copie des propriétés de l'instance et partage des références aux méthodes, ce qui économise au maximum la mémoire. .

En plus des méthodes ci-dessus, il existe également le mode prototype dynamique, le mode construction parasite et le mode construction solide, mais en raison de la faible fréquence d'utilisation, je n'entrerai pas dans les détails.