Suivez-moi pour découvrir 8 façons de créer des objets (classes) en JavaScript

8 façons de créer des objets (classes) en JavaScript, Yiyi vous les présente, j'espère qu'elles vous plairont.

1. Utilisez le constructeur Object pour créer un objet

Le code suivant crée un objet personne et imprime la valeur de l'attribut Name de deux manières.

 var person = new Object();
  person.name="kevin";
  person.age=31;
  alert(person.name);
  alert(person["name"])

Une autre forme de la méthode d'écriture ci-dessus consiste à utiliser des littéraux d'objet pour créer un objet. Ne soyez pas surpris par la personne [« 5 »], c'est légal ici ; sinon, utilisez ceci. De manière entre parenthèses, il peut y avoir des espaces entre les champs, tels que personne["mon âge"].

var person = 
  {
    name:"Kevin",
    age:31,
    5:"Test"
  };
  alert(person.name);
  alert(person["5"]);

Bien que le constructeur d'objet ou le littéral d'objet peut être utilisé pour créer un seul objet, mais ces méthodes ont un inconvénient évident : utiliser la même interface pour créer plusieurs objets produira beaucoup de code en double. Pour résoudre ce problème, les gens ont commencé à utiliser une variante du modèle d’usine.

2. Modèle d'usine

Le modèle d'usine est un modèle de conception bien connu dans le domaine du génie logiciel. Ce modèle résume le processus de création d'objets spécifiques. dans ECMAScript Comme les classes ne pouvaient pas être créées, les développeurs ont inventé des fonctions pour encapsuler les détails de la création d'objets avec une interface spécifique, comme le montre l'exemple suivant.

function createPerson(name, age, job){
  var o = new Object();
  o.name = name;
  o.age = age;
  o.job = job;
  o.sayName = function(){
    alert(this.name);
  };
  return o;
}
var person1 = createPerson("Nicholas", 29, "Software Engineer");
var person2 = createPerson("Greg", 27, "Doctor");

Bien que le modèle d'usine résolve le problème de la création de plusieurs objets similaires, il ne résout pas le problème de la reconnaissance des objets (c'est-à-dire comment connaître le type d'un objet) . Avec le développement de JavaScript
, un autre nouveau modèle est apparu.

3. Modèle de constructeur

Les constructeurs comme Object et Array apparaîtront automatiquement dans l'environnement d'exécution au moment de l'exécution. De plus, vous pouvez créer des constructeurs personnalisés pour définir les propriétés et les méthodes des types d'objets personnalisés. Par exemple, l'exemple précédent peut être réécrit comme suit en utilisant le modèle constructeur.

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = function(){
  alert(this.name);
};
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

Dans cet exemple, la fonction Person() remplace la fonction createPerson(). Nous avons remarqué qu'en plus des mêmes parties que createPerson(), le code dans Person() présente également les différences suivantes :

• L'objet n'est pas explicitement créé

• attribue directement des propriétés et des méthodes à cet objet ;

• n'a pas d'instruction return.

Pour créer une nouvelle instance de Person, l'opérateur new doit être utilisé. Appeler le constructeur de cette manière passera en fait par les 4 étapes suivantes :

(1) Créer un nouvel objet
(2) Construire la portée ; de la fonction est assigné au nouvel objet (donc cela pointe vers le nouvel objet)
(3) exécute le code dans le constructeur (ajoute des attributs au nouvel objet
(4) renvoie le nouvel objet) ; .
À la fin de l'exemple précédent, personne1 et personne2 détiennent chacune une instance différente de Personne. Les deux objets ont un attribut constructeur qui pointe vers Person comme indiqué ci-dessous.

alert(person1.constructor == Person); //true
alert(person2.constructor == Person); //true

L'attribut constructeur d'un objet est initialement utilisé pour identifier le type d'objet. Cependant, lorsqu'il s'agit de détecter des types d'objets, l'opérateur instanceof est plus fiable. Tous les objets que nous créons dans cet exemple sont à la fois des instances de Object et des instances de Person, qui peuvent être vérifiées via l'opérateur instanceof.

alert(person1 instanceof Object); //true
alert(person1 instanceof Person); //true
alert(person2 instanceof Object); //true
alert(person2 instanceof Person); //true

Créer un constructeur personnalisé signifie qu'à l'avenir, vous pourrez identifier ses instances comme un type spécifique ; c'est là que le modèle de constructeur surpasse le modèle d'usine. Dans cet exemple, person1 et person2 sont tous deux des instances de Object car tous les objets héritent de Object.

Problèmes avec les constructeurs

Bien que le modèle de constructeur soit facile à utiliser, il n'est pas sans défauts. Le principal problème lié à l’utilisation des constructeurs est que chaque méthode doit être recréée sur chaque instance.

Les fonctions dans ECMAScript sont des objets, donc chaque fois qu'une fonction est définie, un objet est instancié. D'un point de vue logique, le constructeur à ce moment peut également être défini comme ceci.

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = new Function("alert(this.name)"); // 与声明函数在逻辑上是等价的
}

En regardant le constructeur de ce point de vue, il est plus facile de comprendre l'essence du fait que chaque instance de Person contient une instance de Function différente (pour afficher l'attribut name). Pour être clair, la création d'une fonction de cette manière entraîne différentes chaînes de portée et résolutions d'identifiants, mais le mécanisme de création de nouvelles instances de Function est toujours le même. Par conséquent, les fonctions portant le même nom sur différentes instances ne sont pas égales, comme peut le prouver le code suivant.

alert(person1.sayName == person2.sayName); //false

Cependant, il n'est vraiment pas nécessaire de créer deux instances de Function pour accomplir la même tâche ; objet avant d’exécuter le code ci-dessus. Par conséquent, vous pouvez résoudre ce problème en déplaçant la définition de fonction en dehors du constructeur comme suit.

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = sayName;
}
function sayName(){
  alert(this.name);
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

Si l'objet doit définir de nombreuses méthodes, alors de nombreuses fonctions globales doivent être définies, donc notre type de référence personnalisé n'a aucune encapsulation. Heureusement, ces problèmes peuvent être résolus en utilisant le modèle prototype.

4. Mode prototype

function Person(){
}
Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
  alert(this.name);
};
var person1 = new Person();
person1.sayName(); //"Nicholas"
var person2 = new Person();
person2.sayName(); //"Nicholas"
alert(person1.sayName == person2.sayName); //true

要理解原型对象，可见我的另一篇博客：JavaScript prototype详解

前面例子中每添加一个属性和方法就要敲一遍Person.prototype。为减少不必要的输入，也为了从视觉上更好地封装原型的功能，更常见的做法是用一个包含所有属性和方法的对象字面量来重写整个原型对象，如下面的例子所示。

function Person(){
}
Person.prototype = {
  name : "Nicholas",
  age : 29,
  job: "Software Engineer",
  sayName : function () {
    alert(this.name);
  }
};

在上面的代码中，我们将Person.prototype 设置为等于一个以对象字面量形式创建的新对象。最终结果相同，但有一个例外：constructor 属性不再指向Person 了。前面曾经介绍过，每创建一个函数，就会同时创建它的prototype 对象，这个对象也会自动获得constructor 属性。而我们在这里使用的语法，本质上完全重写了默认的prototype 对象，因此constructor 属性也就变成了新对象的constructor 属性（指向Object 构造函数），不再指向Person 函数。此时，尽管instanceof操作符还能返回正确的结果，但通过constructor 已经无法确定对象的类型了，如下所示。

var friend = new Person();
alert(friend instanceof Object); //true
alert(friend instanceof Person); //true
alert(friend.constructor == Person); //false
alert(friend.constructor == Object); //true

在此，用instanceof 操作符测试Object 和Person 仍然返回true，但constructor 属性则等于Object 而不等于Person 了。如果constructor 的值真的很重要，可以像下面这样特意将它设置回适当的值。

function Person(){
}
  Person.prototype = {
  constructor : Person,
  name : "Nicholas",
  age : 29,
  job: "Software Engineer",
  sayName : function () {
    alert(this.name);
  }
};

需要注意一点就是：实例中的指针仅指向原型，而不指向构造函数。

原型对象的问题：原型模式也不是没有缺点。首先，它省略了为构造函数传递初始化参数这一环节，结果所有实例在默认情况下都将取得相同的属性值。虽然这会在某种程度上带来一些不方便，但还不是原型的最大问题。原型模式的最大问题是由其共享的本性所导致的。

function Person(){
}
Person.prototype = {
  constructor: Person,
  name : "Nicholas",
  age : 29,
  job : "Software Engineer",
  friends : ["Shelby", "Court"],
  sayName : function () {
    alert(this.name);
  }
};
var person1 = new Person();
var person2 = new Person();
person1.friends.push("Van");
alert(person1.friends); //"Shelby,Court,Van"
alert(person2.friends); //"Shelby,Court,Van"
alert(person1.friends === person2.friends); //true

5、组合使用构造函数模式和原型模式（最常用）

创建自定义类型的最常见方式，就是组合使用构造函数模式与原型模式。构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。结果，每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法的引用，最大限度地节省了内存。另外，这种混成模式还支持向构造函数传递参数；可谓是集两种模式之长。

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.friends = ["Shelby", "Court"];
}

Person.prototype = {
  constructor : Person,
  sayName : function(){
    alert(this.name);
  }
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");
person1.friends.push("Van");
alert(person1.friends); //"Shelby,Count,Van"
alert(person2.friends); //"Shelby,Count"
alert(person1.friends === person2.friends); //false
alert(person1.sayName === person2.sayName); //true

6、动态原型模式

有其他OO 语言经验的开发人员在看到独立的构造函数和原型时，很可能会感到非常困惑。动态原型模式正是致力于解决这个问题的一个方案，它把所有信息都封装在了构造函数中，而通过在构造函数中初始化原型（仅在必要的情况下），又保持了同时使用构造函数和原型的优点。换句话说，可以通过检查某个应该存在的方法是否有效，来决定是否需要初始化原型。来看一个例子。

function Person(name, age, job){
  //属性
  this.name = name;
  this.age = age;
  this.job = job;
  //方法
  ---------------------------------------------
  if (typeof this.sayName != "function"){
    Person.prototype.sayName = function(){
      alert(this.name);
    };
  }
  --------------------------------------------  
}
var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName();

7、寄生构造函数模式

通常，在前述的几种模式都不适用的情况下，可以使用寄生（parasitic）构造函数模式。这种模式的基本思想是创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象；但从表面上看，这个函数又很像是典型的构造函数。下面是一个例子。

function Person(name, age, job){
  var o = new Object();
  o.name = name;
  o.age = age;
  o.job = job;
  o.sayName = function(){
    alert(this.name);
  };
  return o;
}
var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName(); //"Nicholas"

在这个例子中，Person 函数创建了一个新对象，并以相应的属性和方法初始化该对象，然后又返回了这个对象。除了使用new 操作符并把使用的包装函数叫做构造函数之外，这个模式跟工厂模式其实是一模一样的。构造函数在不返回值的情况下，默认会返回新对象实例。

8、稳妥构造函数模式

所谓稳妥对象，指的是没有公共属性，而且其方法也不引用this 的对象。稳妥对象最适合在一些安全的环境中（这些环境中会禁止使用this 和new），或者在防止数据被其他应用程序（如Mashup程序）改动时使用。稳妥构造函数遵循与寄生构造函数类似的模式，但有两点不同：一是新创建对象的实例方法不引用this；二是不使用new 操作符调用构造函数。按照稳妥构造函数的要求，可以将前面的Person 构造函数重写如下。

function Person(name, age, job){
  //创建要返回的对象
  var o = new Object();
  //可以在这里定义私有变量和函数
  //添加方法
  o.sayName = function(){
    alert(name);
  };
//返回对象
return o;
}

Avez-vous appris les 8 méthodes ci-dessus pour créer des objets (classes) en JavaScript ? J'espère que cela vous sera utile pour votre apprentissage ?

【Tutoriels associés recommandés】

1. Tutoriel vidéo JavaScript
2 Manuel en ligne JavaScript
3. tutoriel bootstrap