Pourquoi JavaScript a-t-il besoin de prototypes et de chaînes de prototypes ?

Pourquoi les prototypes et les chaînes de prototypes sont-ils nécessaires en JavaScript ?

Dans le processus d'apprentissage de JavaScript, nous rencontrons souvent les notions de prototype et de chaîne de prototypes. Alors, pourquoi les prototypes et les chaînes de prototypes sont-ils nécessaires en JavaScript ? Cet article expliquera ce problème à travers des exemples de code spécifiques.

Tout d’abord, comprenons les prototypes en JavaScript. En JavaScript, chaque objet possède un objet prototype. Nous pouvons obtenir le prototype d'un objet grâce à la méthode Object.getPrototypeOf. Object.getPrototypeOf方法来获取一个对象的原型。

let obj = {};
let proto = Object.getPrototypeOf(obj);

console.log(proto); // 输出: {}

上述代码中，我们创建了一个空对象obj，然后通过Object.getPrototypeOf方法获取了它的原型对象，最后打印出来。由于obj是一个空对象，所以它的原型对象是一个空对象{}。

接下来，让我们来看一下原型的作用。在JavaScript中，每个对象都可以访问其原型对象中的属性和方法。如果一个对象访问一个属性或方法，但该对象本身并没有该属性或方法，那么JavaScript会自动去该对象的原型对象中查找。

let obj = {};
obj.toString(); // 对象自身没有toString方法，会从原型中查找

在上述代码中，我们尝试调用一个空对象obj的toString方法。然而，obj并没有toString方法，所以JavaScript会去obj的原型对象中查找。由于对象默认的原型对象是{}，而{}中包含了toString方法，所以最终可以成功调用obj的toString方法。

原型链是一种用于查找对象属性和方法的机制，在JavaScript中非常重要。当一个对象查找属性或方法时，如果对象本身没有，就会去原型对象中查找。如果原型对象也没有，就会继续去原型的原型对象中查找，以此类推，直到找到该属性或方法，或者达到原型链的顶端，即null。

下面通过一个示例来演示原型链是如何工作的：

let parent = {
  name: "John",
  sayHello: function() {
    console.log("Hello, " + this.name)
  }
};

let child = Object.create(parent);
child.name = "Alice";
child.sayHello(); // 输出：Hello, Alice

在上述代码中，我们创建了一个名为parent的对象，并设置了一个name属性和一个sayHello方法。然后，通过Object.create方法以parent为原型创建了一个名为child的对象。接着，我们在child对象上添加了一个name属性。最后，我们调用了child对象的sayHello方法，成功输出了Hello, Alice。

在上述示例中，当child对象调用sayHello方法时，并没有找到该方法。但是，JavaScript会去child对象的原型对象中查找，即parent对象。在parent对象中找到了sayHellorrreee

Dans le code ci-dessus, nous créons un objet vide obj, puis obtenons son objet prototype via la méthode Object.getPrototypeOf, et enfin l'imprimons. Puisque obj est un objet vide, son objet prototype est un objet vide {}.

Ensuite, examinons le rôle des prototypes. En JavaScript, chaque objet a accès aux propriétés et méthodes de son objet prototype. Si un objet accède à une propriété ou une méthode, mais que l'objet lui-même ne possède pas la propriété ou la méthode, JavaScript la recherchera automatiquement dans l'objet prototype de l'objet.

rrreee

Dans le code ci-dessus, nous essayons d'appeler la méthode toString d'un objet vide obj. Cependant, obj n'a pas de méthode toString, donc JavaScript la recherchera dans l'objet prototype de obj. Étant donné que l'objet prototype par défaut de l'objet est {} et que {} contient la méthode toString, objtoString de /code>. 🎜🎜La chaîne de prototypes est un mécanisme permettant de trouver des propriétés et des méthodes d'objet et est très importante en JavaScript. Lorsqu'un objet recherche une propriété ou une méthode, si l'objet lui-même n'en possède pas, il la recherchera dans l'objet prototype. S'il n'y a pas d'objet prototype, il continuera à chercher dans l'objet prototype du prototype, et ainsi de suite, jusqu'à ce que la propriété ou la méthode soit trouvée, ou que le sommet de la chaîne du prototype soit atteint, c'est-à-dire null. 🎜🎜Ce qui suit est un exemple pour démontrer le fonctionnement de la chaîne de prototypes : 🎜rrreee🎜Dans le code ci-dessus, nous créons un objet nommé parent et définissons un attribut name code> et un Méthode <code>sayHello. Ensuite, un objet nommé child est créé avec parent comme prototype via la méthode Object.create. Ensuite, nous avons ajouté un attribut name sur l'objet child. Enfin, nous avons appelé la méthode sayHello de l'objet child et avons réussi à générer Bonjour, Alice. 🎜🎜Dans l'exemple ci-dessus, lorsque l'objet child appelle la méthode sayHello, la méthode n'est pas trouvée. Cependant, JavaScript le recherchera dans l'objet prototype de l'objet child, qui est l'objet parent. La méthode sayHello a été trouvée dans l'objet parent, elle a donc été appelée avec succès. 🎜🎜Grâce à l'introduction et aux exemples ci-dessus, nous pouvons voir l'importance des prototypes et des chaînes de prototypes. Ils permettent à JavaScript d'implémenter un héritage basé sur des prototypes et de partager des propriétés et des méthodes entre objets, améliorant ainsi la réutilisabilité et l'efficacité du code. 🎜🎜Pour résumer, la raison pour laquelle les prototypes et les chaînes de prototypes sont nécessaires en JavaScript est pour obtenir des méthodes d'héritage et de propriété partagée. Grâce au mécanisme de chaîne de prototypes, JavaScript peut partager des propriétés et des méthodes entre les objets, améliorant ainsi la réutilisabilité et l'efficacité du code. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!