Die Erklärung in den Kommentaren ist sehr detailliert, daher werde ich hier nicht viel Unsinn sprechen. Geben Sie einfach den Code ein:
<script type = "text/javaScript"> // ecma-262 definiert ein Objekt als: "Eine Sammlung von nicht ordnungsgemäßen Attributen, deren Attribute grundlegende Werte, Objekte oder Funktionen enthalten können" // Der einfachste Weg, das Objekt zu verstehen, besteht darin, eine Instanz des Objekts zu erstellen und Attribute und Methoden zu Methoden hinzuzufügen var person = neues Objekt (). Person.name = "xulei"; Person.age = "23"; Person.job = "Front-End-Ingenieur"; Person.sayname = function () {alert (this.name); } // Sie können auch var person = {name: "xulei", Alter: 23, Job: "Front-End Engineering", SayName: Function () {alert (this.name)}} // 1 schreiben. Attributtyp: Datenattribut und Zugriff auf sein Attribut // 1. Datenattribut gibt 4 Eigenschaften, die sein Verhalten beschreiben // [Konfigurierbar]: Zeigt an, ob das Attribut gelöscht werden kann, um das Attribut neu zu definieren, ob das Attribut geändert werden kann oder ob das Attribut an das Accessor-Attribut geändert werden kann. Der Standardwert ist wahr // [Enumerable]: Zeigt an, ob das Attribut zurückgegeben wird. Der Standardwert ist True // [Wert]: Enthält den Datenwert dieses Attributs. Der Standardwert ist undefined var person = {name: "xulei"} // Ein Personenobjekt wird hier erstellt, und der Wertwert ist "xulei" //, um die Standardeigenschaften der Eigenschaft, ECMascript5 -Objekt, zu ändern. Oder alert (peron.name); // xu lei-xulei peron.name = "xu Lei"; Alert (Peron.Name); // xu lei-xulei // Die oben genannten Operationen werden im Nicht-Street-Modus ignoriert. Wenn eine Ausnahme im strengen Modus geworfen wird // Sobald das Attribut als unkonfigurierbar definiert ist, kann es nicht wieder konfigurierbar gemacht werden. // In den meisten Fällen ist es nicht erforderlich, diese vom Objekt bereitgestellten erweiterten Funktionen zu verwenden. DefineProperty () Methode. Aber es ist sehr nützlich, um JavaScript zu verstehen. // Lesern wird empfohlen, diese Methode nicht auf IE8 zu verwenden. // 2. Der Zugriff auf seine Eigenschaften hat 4 Eigenschaften // [Konfigurierbar]: Gibt an, ob das Attribut gelöscht werden kann, um das Attribut neu zu definieren, ob die Eigenschaften des Attributs geändert werden können oder ob das Attribut an das Accessor-Attribut geändert werden kann, der Standardwert ist wahr // [Enumerable]: Zeigt an, ob das Attribut. UNDEFINDED // [SET]: Der Standardwert der Funktion, das beim Schreiben des Attributs Undefined var book = {_year: 2004, Edition: 1} Objekt.DefineProperty (Buch, "Jahr", {get: function () {return this._year; }); book.year = 2005; alert (book.edition); // 2 // ein Objekt erstellen // 1. Behandle den Konstruktor als Funktionsperson (Name, Alter, Job) {this.name = name; this.age = Alter; this.job = Job; this.sayname = function () {alert (this.name); }} // Verwenden Sie var person = new Person ("xulei", 23, "Software"); Person.SayName (); // benutze Person ("xulei2", 23, "Job2"); // Hinzufügen zu window.sayname (); // var im Bereich eines anderen Objekts aufrufen o = neues Objekt (); Person.call (o, "xulei3", 23, "Job3"); O.SayName (); </script>Lassen Sie uns einen weiteren Absatz haben:
<script type = "text/javaScript"> // 1. Verstehen Sie das Prototypobjekt // 2. Prototyp und im Operator // 3. Einfachere Prototypsyntax // 4. Dynamik des Prototyps // 5. Native Objektprototyp // 6. Probleme mit dem Prototypobjekt // 1. Immer wenn eine Funktion erstellt wird, wird für die Funktion ein Prototyp -Attribut erstellt, das auf einem bestimmten Satz von Regeln basiert. Dieses Attribut zeigt auf das Prototyp -Objekt der Funktion // standardmäßig erhalten alle Prototyp -Objekte automatisch einen Konstruktor (Konstruktor) Attribut, der einen Zeiger auf die Funktion enthält, bei dem sich das Prototyp -Attribut befindet // wie Funktionsperson () {} //person.Prototype.Constructor -Punkte. Was andere Methoden betrifft, werden sie von Object.////Wenn der Aufruf zur Erstellung einer neuen Instanz geerbt wird, enthält die Instanz einen Zeiger (interne Eigenschaft), um auf das Prototyp -Objekt des Konstruktors zu verweisen. alert (person.prototype.isprototypeof (p1)) alert (Object.getPrototypeof (p1) == Person.Prototyp) // Obwohl der im Prototyp gespeicherte Wert über die Objektinstanz auf den Wert im Prototyp nicht über die Objektinstanz zugegriffen werden kann. Wenn wir der Instanz eine Eigenschaft // hinzufügen und der Name der Eigenschaft die gleiche Instanz im Prototyp entspricht, erstellen wir die Eigenschaft in der Instanz, und die Eigenschaft blockiert die Eigenschaft im Prototyp. EG: Funktion person () {} Person.Prototype.Name = "Amber"; Person.Prototype.age = 23; Person.Prototype.job = "Software Engineer"; Person.Prototype.sayname = function () {alert (this.name)} var person1 = new Person (); var person2 = new Person (); Person1.Name = "Amber.xu"; alert (person1.name); // Amber.xu ---From Instance alarm (Person2.Name); // Amber ---From Prototype Person.name; Alert (Person1.Name); // Amber -FROM DER PROTOTYP // Verwenden Sie die Methode von HasownProperty (), um festzustellen, ob in der Instanz oder im Prototyp eine Eigenschaft vorliegt. Diese Methode (aus dem Objekt geerbt) // Return true Function Person () {} Person.Prototype.name = "Amber"; Person.Prototype.age = 23; Person.Prototype.job = "Software Engineer"; Person.Prototype.sayname = function () {alert (this.name)} var person1 = new Person (); var person2 = new Person (); Alert (Person1.hasownProperty ("Name")); // false aus der Instanz -Alert (Person2.hasownProperty ("Name")); // false aus der Instanzperson1.Name = "Amber.xu"; Alert (Person1.Name); Alert (Person1.hasownProperty ("Name")); // true aus der Instanzperson1.Name; Alert (Person1.Name); alert (Person1.hasownProperty ("Name")); // false aus dem Prototyp // 2. Prototyp und im Operator // In zwei Möglichkeiten, es zu verwenden, wird man separat und in für In-in verwendet. Wenn der Operator alleine verwendet wird, gibt er true zurück, wenn das Objekt auf eine bestimmte Eigenschaft zugreifen kann // Unabhängig davon, ob die Eigenschaft vom Prototyp oder der Instanzfunktion Person () {} Person.Prototype.Name = "Amber" stammt; Person.Prototype.age = 23; Person.Prototype.job = "Software Engineer"; Person.Prototype.sayname = function () {alert (this.name)} var person1 = new Person (); var person2 = new Person (); alert ("name" person1); // true aus der Prototypen alert ("name" in person2); // true aus der prototypen alert ("Höhe" persönlich); // false // Auf diese Weise können Sie eine Funktion einkapitulieren (ob die angegebene Eigenschaft die angegebene Eigenschaft für das angegebene Objekt) Funktion HaSprototypepopery (Objectiony). } alert("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Returns all Aufzählbare Eigenschaften, auf die sowohl Prototyp- als auch Instanzeigenschaften zugegriffen werden können. o = {toString: function () {return "mein Objekt"; Akzeptieren Sie ein Objekt als Argument, // ein String -Array, das alle aufzählbaren Eigenschaften Funktion person () {} Person.Prototype.Name = "Amber" enthält; Person.Prototype.age = 23; Person.Prototype.job = "Software Engineer"; Person.Prototype.sayname = function () {alert (this.name)} var person1 = new Person (); var person2 = new Person (); var keys = Object.Keys (Person.Prototype); alert (keys) person1.name = "Amber.xu"; Person1.age = 23; var keys = Object.Keys (Person1); Alarm (Schlüssel) Alarm("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Name: "Amber", Alter: 23, Job: "Software", SayName: Function () {Alert (this.name)}} // Nach dem Schreiben ist das Konstruktor -Attribut nicht mehr auf die Personfunktion, sondern auf den Objektkonstruktor, obwohl das korrekte Ergebnis durch die Art des Operators zurückgegeben werden kann Person) // True Alert (Freundinstanz von Objekt) // True Alert (Freund.Constructor == Person); // false alarm (Freund.Constructor == Objekt); // true // Wenn der Konstruktor für Sie wirklich wichtig ist, können Sie es auf den entsprechenden Wert wie unten bewertet () {{} Person. sayName: function () {alert (this.name)}} var Freund = new Person (); alarm ("manuell eingestellt constructor----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // In diesem Fall können Sie Objekt verwenden. Zwischen der Instanz und dem Prototyp ist die Verbindung zwischen der Instanz und dem Prototyp nur ein Zeiger, keine Kopie // Wenn wir die Methode Sayhi () aufrufen, werden wir zunächst nach einer Methode namens Sayhi in der Instanz suchen und nach dem Prototyp suchen, wenn es nicht gefunden wird. // Wenn Sie jedoch das gesamte Prototypobjekt umschreiben, ist die Situation unterschiedlich. // Wir wissen, dass beim Aufrufen des Konstruktors ein Prototyp -Zeiger auf den ursprünglichen Prototyp zur Instanz hinzugefügt wird, und das Ändern des Prototyps an ein anderes Objekt entspricht dem Abbau der Verbindung zwischen dem Konstruktor und dem ursprünglichen Prototyp. // Denken Sie daran: Der Zeiger in der Instanz zeigt nur auf den Prototyp, nicht auf den Konstruktor. zB: Funktion a () {} var a1 = new a (); A.Prototype = {Konstruktor: a, Name: "Amber", Alter: 23, Job: "Software", SayName: function () {alert (this.name)}} alert("ERROR------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Even all Native Referenztypen werden mit diesem Muster erstellt. String.Prototype.Startswith = Funktion (text) {return this.indexof (text) == 0; }; var msg = "Hallo"; Alert (msg.Startswith ("H")); // Wir empfehlen dies nicht. alert ("Prototypproblem mit Prototypobjekt"); // 6. Prototyp -Beispielfunktion ques () {} ques.Prototype = {Konstruktor: Ques, Name: "Amber", Alter: 23, Job: "IT", Freunde: ["Zhang san", "li si"], // Referenztyp Sayname: function () {alert (this.name)}}; var q1 = new ques (); var q2 = new ques (); q1.friends.push ("Wang Wu"); alert (q1.friends); // alert (q2.friends); // alert (q1.friends === q2.friends); // Ich glaube, jeder hat das Problem gesehen. Als ich zwei Instanzen Q1 und Q2 erstellte und als ich "Freunde" von Q1 "Wang Wu" hinzufügte, hatten "Freunde" von Q2 auch drei "Wang San, Li Si und Wang Wu // Das liegt daran, dass das Array auf Ques existiert.Dieser Artikel endet hier. Wir werden in Zukunft weiterhin die objektorientierte Programmierung von JavaScript diskutieren. Ich hoffe, es kann es mögen.