Je lis actuellement "Javascript Advanced Programming" (deuxième édition)
Création d'objets en javascript
•Mode Usine
•Modèle de constructeur
•Mode Prototype
• Combiner des modèles de constructeur et de prototype
•Mode dynamique du prototype
La plupart des langages orientés objet ont le concept de classe, à travers laquelle plusieurs objets avec les mêmes méthodes et propriétés peuvent être créés. Bien que techniquement parlant, JavaScript soit un langage orienté objet, JavaScript n'a pas la notion de classes, tout est objet. Tout objet est une instance d'un certain type de référence, qui est créée via un type de référence existant ; le type de référence peut être natif ou personnalisé. Les types de référence natifs incluent : Objet, Tableau, Données, RegExp et Fonction. ! Un type référence est une structure de données qui organise les données et les fonctionnalités, souvent appelée classe. En JavaScript, qui manque du concept de classes, le problème à résoudre est de savoir comment créer efficacement des objets.
1.1.0. Méthodes générales de création d'objets
var person = {}; //对象字面量表示，等同于var person = new Objcect();
person.name = 'evansdiy';
person.age = '22';
person.friends = ['ajiao','tiantian','pangzi'];
person.logName = function() {
console.log(this.name);
}Sur la base du type de référence Object, un objet est créé, qui contient quatre propriétés, dont l'une est une méthode. Si vous avez besoin de nombreuses instances d'objets ressemblant à des personnes, il y aura beaucoup de code en double.
1.1.1. Mode usine [haut]
Créez un objet via une fonction pouvant contenir des détails sur l'objet, puis renvoyez cet objet.
function person(name,age,friends) {
var o = {
name: name,
age: age,
friends: friends,
logName: function() {
console.log(this.name);
}
};
return o;
}
var person1 = person('Evansdiy','22',['ajiao','tiantian','pangzi']);Chaque fois que la fonction personne est appelée, un nouvel objet sera créé via l'objet o à l'intérieur de la fonction, puis renvoyé. A part cela, l'objet interne o qui existe pour créer un nouvel objet n'a pas d'autre but. De plus, il est impossible de déterminer le type d’objet créé par le modèle d’usine.
1.1.2. Modèle de constructeur [haut]
function Person(name,age,job) {
this.name = name;
this.age = age;
this.job = job;
this.logName = function() {
console.log(this.name);
}
}
//通过new操作符创建Person的实例
var person1 = new Person('boy-a','22','worker');
var person2 = new Person('girl-b','23','teacher');
person1.logName(); //boy-a
person2.logName(); //girl-aEn comparant le modèle d'usine, vous constaterez qu'il n'est pas nécessaire de créer des objets intermédiaires et qu'il n'y a pas de retour. De plus, l'instance du constructeur peut être identifiée comme un type spécifique, ce qui résout le problème de l'identification des objets (en vérifiant la propriété constructeur de l'instance ou en utilisant l'opérateur instanceof pour vérifier si l'instance a été créée via un certain constructeur) .
console.log(person1.constructor == Person);//constructor est situé dans le prototype du constructeur et pointe vers le constructeur, et le résultat est vrai
console.log(person1 instanceof Person);//Utilisez l'opérateur instanceof pour déterminer si person1 est une instance du constructeur Person. Cependant, le mode constructeur a également ses propres problèmes. En fait, la méthode logName sera redémarrée. sur chaque instance. Créez une fois. Il convient de noter que les méthodes créées par instanciation ne sont pas égales. Le code suivant deviendra faux :
console.log(person1.logName == person2.logName);//false On peut déplacer la méthode hors du constructeur (devenir une fonction globale) pour résoudre ce problème :
function logName() {
console.log(this.name);
}
function logAge() {
console.log(this.age);
}Cependant, la fonction globale créée sous la fonction globale ne peut en réalité être appelée que par l'instance créée par Person, ce qui est un peu indigne de son nom s'il existe de nombreuses méthodes, il faut les définir une par une, faute de quoi ; encapsulation.
1.1.3. Mode Prototype [haut]
Chaque fonction en JavaScript contient un pointeur vers l'attribut prototype (la plupart des navigateurs peuvent y accéder via l'attribut interne __proto__). L'attribut prototype est un objet qui contient toutes les instances créées par un certain type de référence.
function Person() {}
Person.name = 'evansdiy';
Person.prototype.friends = ['ajiao','jianjian','pangzi'];
Person.prototype.logName = function() {
console.log(this.name);
}
var person1 = new Person();
person1.logName();//'evansdiy'Le code ci-dessus fait les choses suivantes :
1. Une fonction constructeur Personne est définie, et la fonction Personne obtient automatiquement un attribut prototype, qui par défaut ne contient qu'un attribut constructeur pointant vers Personne
;2. Ajoutez trois attributs via Person.prototype, dont l'un est une méthode
;3. Créez une instance de Person puis appelez la méthode logName() sur l'instance.
Ce qu'il faut noter ici, c'est le processus d'appel de la méthode logName() :
1. Recherchez la méthode logName() sur l'instance person1 et constatez qu'une telle méthode n'existe pas, nous la remontons donc au prototype de person1
2. Recherchez la méthode logame() sur le prototype de person1, donc l'appel de cette méthode est basé sur un tel processus de recherche. Nous pouvons empêcher l'instance d'accéder au prototype en définissant l'attribut du même nom. dans le prototype sur l'instance. Attributs portant le même nom. Il convient de noter que cela ne supprimera pas les attributs portant le même nom sur le prototype, mais empêchera uniquement l'accès à l'instance.
var personne2 = new Personne();
person2.name = 'laocai'; Si nous n'avons plus besoin des attributs sur l'instance, nous pouvons les supprimer via l'opérateur delete.
delete person2.name; Utilisez une boucle for-in pour énumérer tous les attributs auxquels l'instance peut accéder (que l'attribut existe dans l'instance ou dans le prototype) :
for(i in person1) {
console.log(i);
}同时，也可以利用hasOwnProperty()方法判断某个属性到底存在于实例上，还是存在于原型中，只有当属性存在于实例中，才会返回true：
console.log(person1.hasOwnProperty('name'));//true！hasOwnProperty来自Object的原型，是javascript中唯一一个在处理属性时不查找原型链的方法。[via javascript秘密花园] 另外，也可以通过同时使用in操作符和hasOwnProperty()方法来判断某个属性存在于实例中还是存在于原型中：
console.log(('friends' in person1) && !person1.hasOwnProperty('friends'));先判断person1是否可以访问到friends属性，如果可以，再判断这个属性是否存在于实例当中（注意前面的!），如果不存在于实例中，就说明这个属性存在于原型中。 前面提到，原型也是对象，所以我们可以用对象字面量表示法书写原型，之前为原型添加代码的写法可以修改为：
Person.prototype = {
name: 'evansdiy',
friends: ['ajiao','jianjian','pangzi'],
logName: function() {
console.log(this.name);
}
}由于对象字面量语法重写了整个prototype原型，原先创建构造函数时默认取得的constructor属性会指向Object构造函数：
//对象字面量重写原型之后
console.log(person1.constructor);//Object不过，instanceof操作符仍会返回希望的结果：
//对象字面量重写原型之后
console.log(person1 instanceof Person);//true当然，可以在原型中手动设置constructor的值来解决这个问题。
Person.prototype = {
constructor: Person,
......
}如果在创建对象实例之后修改原型对象，那么对原型的修改会立即在所有对象实例中反映出来：
function Person() {};
var person1 = new Person();
Person.prototype.name = 'evansdiy';
console.log(person1.name);//'evansdiy'实例和原型之间的连接仅仅是一个指针，而不是一个原型的拷贝，在原型实际上是一次搜索过程，对原型对象的所做的任何修改都会在所有对象实例中反映出来，就算在创建实例之后修改原型，也是如此。 如果在创建对象实例之后重写原型对象，情况又会如何？
function Person() {};
var person1 = new Person1();//创建的实例引用的是最初的原型
//重写了原型
Person.prototype = {
friends: ['ajiao','jianjian','pangzi']
}
var person2 = new Person();//这个实例引用新的原型
console.log(person2.friends);
console.log(person1.friends);以上代码在执行到最后一行时会出现未定义错误，如果我们用for-in循环枚举person1中的可访问属性时，会发现，里头空无一物，但是person2却可以访问到原型上的friends属性。 ！重写原型切断了现有原型与之前创建的所有对象实例的联系，之前创建的对象实例的原型还在，只不过是旧的。
//创建person1时，原型对象还未被重写，因此，原型对象中的constructor还是默认的Person()
console.log(person1.constructor);//Person()
//但是person2的constructor指向Object()
console.log(person2.constructor);//Object()需要注意的是，原型模式忽略了为构造函数传递参数的过程，所有的实例都取得相同的属性值。同时，原型模式还存在着一个很大的问题，就是原型对象中的引用类型值会被所有实例共享，对引用类型值的修改，也会反映到所有对象实例当中。
function Person() {};
Person.prototype = {
friends: ['ajiao','tiantian','pangzi']
}
var person1 = new Person();
var person2 = new Person();
person1.friends.push('laocai');
console.log(person2.friends);//['ajiao','tiantian','pangzi','laocai']修改person1的引用类型值friends，意味着person2中的friends也会发生变化，实际上，原型中保存的friends实际上只是一个指向堆中friends值的指针（这个指针的长度是固定的，保存在栈中），实例通过原型访问引用类型值时，也是按指针访问，而不是访问各自实例上的副本（这样的副本并不存在）。
1.1.4.结合构造函数和原型模式创建对象 [top]
结合构造函数和原型模式的优点，弥补各自的不足，利用构造函数传递初始化参数，在其中定义实例属性，利用原型定义公用方法和公共属性，该模式应用最为广泛。
function Person(name,age) {
this.name = name;
this.age = age;
this.friends = ['ajiao','jianjian','pangzi'];
}
Person.prototype = {
constructor: Person,
logName: function() {
console.log(this.name);
}
}
var person1 = new Person('evansdiy','22');
var person2 = new Person('amy','21');
person1.logName();//'evansdiy'
person1.friends.push('haixao');
console.log(person2.friends.length);//31.1.5.原型动态模式 [top]
原型动态模式将需要的所有信息都封装到构造函数中，通过if语句判断原型中的某个属性是否存在，若不存在（在第一次调用这个构造函数的时候），执行if语句内部的原型初始化代码。
function Person(name,age) {
this.name = name;
this.age = age;
if(typeof this.logName != 'function') {
Person.prototype.logName = function() {
console.log(this.name);
};
Person.prototype.logAge = function() {
console.log(this.age);
};
};
}
var person1 = new Person('evansdiy','22');//初次调用构造函数，此时修改了原型
var person2 = new Person('amy','21');//此时logName()方法已经存在，不会再修改原型需要注意的是，该模式不能使用对象字面量语法书写原型对象（这样会重写原型对象）。若重写原型，那么通过构造函数创建的第一实例可以访问的原型对象不会包含if语句中的原型对象属性。
function Person(name,age) {
this.name = name;
this.age = age;
if(typeof this.logName != 'function') {
Person.prototype = {
logName: function() {
console.log(this.name);
},
logAge: function() {
console.log(this.Age);
}
}
};
}
var person1 = new Person('evansdiy','22');
var person2 = new Person('amy','21');
person2.logName();//'amy'
person1.logName();//logName()方法不存在需要说明的是，各模式都有自己的应用场景，无所谓优劣。
以上这篇浅析在javascript中创建对象的各种模式就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
