Warum benötigt JavaScript Prototypen und Prototypketten?

Warum werden in JavaScript Prototypen und Prototypenketten benötigt?

Beim Erlernen von JavaScript stoßen wir häufig auf die Konzepte Prototyp und Prototypkette. Warum werden in JavaScript Prototypen und Prototypketten benötigt? In diesem Artikel wird dieses Problem anhand spezifischer Codebeispiele erläutert.

Lassen Sie uns zunächst Prototypen in JavaScript verstehen. In JavaScript hat jedes Objekt ein Prototypobjekt. Wir können den Prototyp eines Objekts über die Methode Object.getPrototypeOf erhalten. 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

Im obigen Code erstellen wir ein leeres Objekt obj, rufen dann sein Prototypobjekt über die Methode Object.getPrototypeOf ab und drucken es schließlich aus. Da obj ein leeres Objekt ist, ist sein Prototypobjekt ein leeres Objekt {}.

Als nächstes werfen wir einen Blick auf die Rolle von Prototypen. In JavaScript hat jedes Objekt Zugriff auf Eigenschaften und Methoden in seinem Prototypobjekt. Wenn ein Objekt auf eine Eigenschaft oder Methode zugreift, das Objekt selbst jedoch nicht über die Eigenschaft oder Methode verfügt, sucht JavaScript automatisch im Prototypobjekt des Objekts danach.

rrreee

Im obigen Code versuchen wir, die Methode toString eines leeren Objekts obj aufzurufen. Da obj jedoch keine Methode toString hat, sucht JavaScript im Prototypobjekt von obj danach. Da das Standardprototypobjekt des Objekts {} ist und {} die Methode toString enthält, kann objs <code>toString-Methode. 🎜🎜Die Prototypenkette ist ein Mechanismus zum Auffinden von Objekteigenschaften und -methoden und in JavaScript sehr wichtig. Wenn ein Objekt nach einer Eigenschaft oder Methode sucht und das Objekt selbst keine hat, wird es im Prototypobjekt danach suchen. Wenn kein Prototypobjekt vorhanden ist, wird die Suche im Prototypobjekt des Prototyps fortgesetzt usw., bis die Eigenschaft oder Methode gefunden wird oder die Spitze der Prototypkette erreicht wird, d. h. null. 🎜🎜Das Folgende ist ein Beispiel, um zu demonstrieren, wie die Prototypenkette funktioniert: 🎜rrreee🎜Im obigen Code erstellen wir ein Objekt mit dem Namen parent und legen ein name code>-Attribut und ein fest <code>sayHello-Methode. Anschließend wird über die Methode Object.create ein Objekt mit dem Namen child mit parent als Prototyp erstellt. Als Nächstes haben wir dem Objekt child ein name-Attribut hinzugefügt. Schließlich haben wir die Methode sayHello des Objekts child aufgerufen und Hello, Alice erfolgreich ausgegeben. 🎜🎜Wenn im obigen Beispiel das child-Objekt die Methode sayHello aufruft, wird die Methode nicht gefunden. JavaScript sucht jedoch im Prototypobjekt des child-Objekts danach, welches das parent-Objekt ist. Die Methode sayHello wurde im Objekt parent gefunden und daher erfolgreich aufgerufen. 🎜🎜Anhand der obigen Einführung und Beispiele können wir die Bedeutung von Prototypen und Prototypenketten erkennen. Sie ermöglichen es JavaScript, eine prototypbasierte Vererbung zu implementieren und Eigenschaften und Methoden zwischen Objekten auszutauschen, wodurch die Wiederverwendbarkeit und Effizienz des Codes verbessert wird. 🎜🎜Zusammenfassend lässt sich sagen, dass der Grund, warum Prototypen und Prototypketten in JavaScript benötigt werden, darin besteht, Vererbungs- und Shared-Property-Methoden zu erreichen. Durch den Prototypkettenmechanismus kann JavaScript Eigenschaften und Methoden zwischen Objekten teilen und so die Wiederverwendbarkeit und Effizienz des Codes verbessern. 🎜

Das obige ist der detaillierte Inhalt vonWarum benötigt JavaScript Prototypen und Prototypketten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!