Beispiele für Instanzobjekte und Prototypobjekte in JavaScript_Grundkenntnisse

Erklären Sie zunächst Folgendes: Jedes Objekt in JavaScript verfügt über ein Konstruktorattribut und ein Prototypattribut. Der Konstruktor zeigt auf den Konstruktor des Objekts, und der Prototyp zeigt auf das Prototypobjekt der Objektinstanz, die mit dem Konstruktor erstellt wurde.

function Person(){ 
  
 } 
var person = new Person(); 
 
Person.prototype = { 
 constructor : Person, 
 name : 'zxs', 
 age : 24, 
 sayName : function(){alert(this.name)} 
 } 
  
person.sayName(); 

In diesem Code wird ein Fehler gemeldet, sayName() ist nicht definiert. Laut JavaScript Advanced Programming Second Edition liegt dies daran, dass der überschriebene Prototyp die Verbindung zwischen dem Konstruktor und dem ursprünglichen Prototyp unterbricht. Aber passen wir die Reihenfolge der obigen Aussagen an. Wie folgt:

function Person(){ 
 } 
//var person = new Person(); 
Person.prototype = { 
 constructor : Person, 
 name : 'zxs', 
 age : 24, 
 sayName : function(){alert(this.name)} 
} 
/*===========================================================*/ 
var person = new Person(); 
/*===========================================================*/ 
 person.sayName(); // zxs 
alert(person.constructor) //function Object() { [native code]} or function Person() {} 取决与蓝色的语句是否有效 

Achten Sie auf die Anweisungen zwischen den Gleichheitszeichen in den beiden Codeteilen oben. Wenn Sie den Code in der Reihenfolge des zweiten Absatzes schreiben, wird „zxs“ ausgegeben. Dieses Ergebnis zeigt, dass der im ersten Fall gemeldete Fehler nicht darauf zurückzuführen ist, dass die Verbindung zwischen dem Konstruktor und der ursprünglichen Idee unterbrochen wurde .

Person.prototype = ｛｝ 

Es ist ursprünglich eine Möglichkeit, Objekte zu definieren, und das Konstruktorattribut jedes Objekts in JavaScript verweist standardmäßig auf den Objektkonstruktor. Dies ist nicht schwer zu zeigen, dass das Umschreiben des Prototypobjekts die Verbindung zwischen dem Konstruktor und dem Objekt unterbricht Dies bedeutet jedoch nicht, dass die Person nicht mehr auf die Funktion sayName() zugreifen kann, nachdem diese Verbindung getrennt wurde.

Nun gibt es diese Annahme: Das Prototypobjekt, auf das das Prototypattribut der Funktion zeigt, ist nicht genau dasselbe wie das neu erstellte Prototypobjekt, das wir anzeigen. Wenn wir eine Funktion aufrufen, prüfen wir zunächst, ob das Prototypobjekt in der aktuellen Umgebung vorhanden ist. Wir werden nach ihren Eigenschaften und Methoden suchen. Basierend auf dem Suchergebnis wird ein Prototypobjekt zurückgegeben. Die Eigenschaften und Methoden in diesem Objekt verwenden immer zuerst die Eigenschaften und Methoden im Standardprototyp, d. h. die in definierten Eigenschaften und Methoden der Konstrukteur. Wenn die aufgerufene Methode oder Eigenschaft im Standardprototyp nicht vorhanden ist, werden die in Person.prototype = {} definierten Eigenschaften und Methoden verwendet.

Javascript ist eine interpretierte Sprache und Anweisungen werden nacheinander ausgeführt, wenn wir das Schlüsselwort new zum Erstellen eines neuen Objekts verwenden. Dies bedeutet, dass die Methoden und Die darin definierten Eigenschaften können in der aktuellen Ausführungsumgebung nicht gefunden werden und die Methode ist im Konstruktor nicht vorhanden, sodass ein Fehler auftritt. Ebenso wie eine Variable kann sie nicht verwendet werden, wenn das Programm beim Zuweisen eines Werts nicht ausgeführt wird. Im zweiten Absatz ist die aufgerufene Methode bereits in der Umgebung vorhanden und das Prototypobjekt des Konstruktors wurde erstellt, sodass das Ergebnis abgerufen werden kann.

Sehen Sie sich das folgende Programm an:

////////////////////////////////////////////////////////////////////////// 
 
function Person(){} 
 
/*===========================================================*/ 
 
 var person = new Person(); 
Person.prototype.name = 'song'; 
 
/*===========================================================*/ 
 
//Person.prototype.sayName = function(){alert(this.name)}; 
Person.prototype = { 
constructor : Person, 
name : 'zxs', 
age : 24, 
sayName : function(){alert(this.name)} 
} 
person.sayName(); // error 
 
////////////////////////////////////////////////////////////////////////// 
 
function Person(){  } 
/*var person = new Person();*/ 
Person.prototype.name = 'song';  
/*Person.prototype.sayName = function(){alert(this.name)};*/ 
Person.prototype = {   
constructor : Person, 
  name : 'zxs', 
  age : 24, 
  sayName : function(){alert(this.name)} 
} 
 
/*===========================================================*/ 
var person = new Person(); 
 
/*===========================================================*/ 
person.sayName(); // zxs 

Hier ist ersichtlich, dass mit Person.prototype.name = '' auf das Objekt zugegriffen werden kann, unabhängig davon, wo es erstellt wird. Wenn durch diese Methode sowohl ein Objektliteral als auch ein Prototypobjekt definiert sind, gilt das spätere Als Endwert wird das definierte Objekt verwendet. Und nachdem eine Objektliteraldefinition für ein Prototypobjekt verwendet wurde, muss die Definition vor der Anweisung stehen, die das Objekt erstellt, bevor darauf zugegriffen werden kann.

Instanzen können nicht auf Eigenschaften und Methoden im Prototypobjekt zugreifen, nicht zuletzt, weil durch das Überschreiben des Prototypobjekts die Verbindung zwischen dem Konstruktor und dem ursprünglichen Prototyp unterbrochen wird.

function Person(){  
    
  }  
var person = new Person();  
  
Person.prototype = {  
  //constructor : Person,  
  name : 'zxs',  
  age : 24,  
  sayName : function(){alert(this.name)}  
  }  
    
person.sayName();  

Der Prototyp der Konstruktorfunktion im obigen Code ist beim Instanziieren des Objekts leer und verfügt über keine anderen Eigenschaften als die Standardeigenschaften. Das Überschreiben des Konstruktor-Prototyps trennt die Verbindung zwischen dem Konstruktor und dem ursprünglichen Prototyp.

Nach der Verwendung des neuen Operators wurden die Eigenschaften und Methoden im Prototypobjekt des Konstruktors dem Personenobjekt hinzugefügt. Da die obige Methode beim Hinzufügen neuer Eigenschaften und Methoden zum Funktionsprototyp nicht dynamisch ist, kann die Person nicht auf die neu hinzugefügten Eigenschaften und Methoden zugreifen.

Nach dem Umschreiben des Prototypobjekts sieht es wie der folgende Code aus:

var o = { 
  name : 'zxs' 
  } 
   
var obj = o; 
o = {} 
console.log(o.name);  

Der Ausgabewert ist zu diesem Zeitpunkt undefiniert, da das Objekt ein Referenztyp ist, „=" der Zuweisungsoperator ist und die Reihenfolge der Operationen von rechts nach links erfolgt. o={} bedeutet, dass sich der Punkt von o geändert hat und ein leeres Objekt ist.
Der Unterschied zwischen Person.prototype.mothed = function() {} und Person.prototype={mothed:function(){}} ist der gleiche wie arr = [] und arr.push() Letzteres verändert sich völlig.