Jedes Objekt in JavaScript verfügt über einen integrierten Eigenschaftsprototyp. Die Erläuterung der Prototyp -Eigenschaft eines Objekts in JavaScript lautet: Rückgabe auf den Objekttyp -Prototyp. Dies bedeutet, dass das Prototyp -Attribut einen Verweis auf ein anderes JavaScript -Objekt enthält, das als übergeordnetes des aktuellen Objekts fungiert.
Die Codekopie lautet wie folgt:
A.Prototype = neu B ();
Das Verständnis des Prototyps sollte nicht mit der Vererbung verwechselt werden. Der Prototyp von A ist eine Instanz von B. Es kann verstanden werden, dass A alle Methoden und Eigenschaften in B. A geklont hat. Was hier betont wird, ist das Klonen und nicht das Erbschaft. Dies kann passieren: As Prototyp ist eine Instanz von B, und Bs Prototyp ist auch eine Instanz von A.
Sehen Sie sich die folgende Analyse fort:
Private Variablen und Funktionen
Wenn die in der Funktion definierten Variablen und Funktionen nicht extern bereitgestellt werden, können sie nicht extern zugreifen, dh auf die privaten Variablen und Funktionen der Funktion.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsbox () {
var color = "blau"; // Private Variable
var fn = function () // Private Funktion
{
}
}
</script>
Auf diese Weise können die Variablen Farbe und FN nicht außerhalb der Funktionsobjektbox zugegriffen werden und werden privat:
Die Codekopie lautet wie folgt:
var obj = new box ();
Alert (obj.color); // undefined Popup
alarm (obj.fn); // wie oben
Statische Variablen und Funktionen
Wenn eine Funktion definiert ist, sind die Attribute und Funktionen, die dazu hinzugefügt wurden, über das Objekt selbst weiterhin zugänglich, auf ihre Beispiele können jedoch nicht zugegriffen werden. Solche Variablen und Funktionen werden als statische Variablen bzw. statische Funktionen bezeichnet.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktion obj () {};
Obj.num = 72; // statische Variable
Obj.fn = function () // statische Funktion
{
}
Alarm (obj.num); // 72
alert (typeof obj.fn) // Funktion
var t = neuer obj ();
ALERT (T.NAME); // UNDEFINED
ALERT (typeof t.fn); // undefiniert
</script>
Instanzvariablen und Funktionen
Bei objektorientierter Programmierung hoffen wir zusätzlich zu einigen Bibliotheksfunktionen immer noch einige Eigenschaften und Methoden gleichzeitig, wenn die Objektdefinition nach der Instanziierung zugegriffen werden kann, und JS kann dies auch tun.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsbox () {
this.a = []; // Instanzvariable
this.fn = function () {// Instanzmethode
}
}
console.log (typeof box.a); //undefiniert
console.log (typeof box.fn); //undefiniert
var box = new box ();
console.log (typeof box.a); //Objekt
console.log (typeof box.fn); //Funktion
</script>
Fügen Sie den Instanzvariablen und -Methoden neue Methoden und Eigenschaften hinzu
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsbox () {
this.a = []; // Instanzvariable
this.fn = function () {// Instanzmethode
}
}
var box1 = new box ();
Box1.A.Push (1);
box1.fn = {};
console.log (box1.a); // [1]
console.log (typeof box1.fn); //Objekt
var box2 = new box ();
console.log (box2.a); // []
console.log (typeof box2.fn); //Funktion
</script>
A und FN wurden in Box1 modifiziert, jedoch nicht in Box2. Da Arrays und Funktionen Objekte und Referenztypen sind, bedeutet dies, dass die Eigenschaften und Methoden in Box1, obwohl sie in Box2 übereinstimmen, keine Referenz sind, sondern eine Kopie der Eigenschaften und Methoden, die vom Box -Objekt definiert sind.
Dies hat kein Problem mit Eigenschaften, aber es ist ein großes Problem für Methoden, da Methoden genau die gleiche Funktion ausführen, aber es gibt zwei Kopien. Wenn ein Funktionsobjekt Tausende und Instanzmethoden hat, muss jede Instanz eine Kopie von Tausenden von Methoden beibehalten. Dies ist offensichtlich unwissenschaftlich. Was kann ich tun? Prototyp entstand.
Grundkonzepte
Jede von uns erstellte Funktion verfügt über eine Prototyp -Eigenschaft, die ein Zeiger auf ein Objekt ist, und ihr Zweck besteht darin, Eigenschaften und Methoden zu enthalten, die von allen Instanzen eines bestimmten Typs gemeinsam genutzt werden können. Anschließend ist Prototyp das Prototypobjekt der Objektinstanz, das durch Aufrufen des Konstruktors erstellt wurde.
Der Vorteil der Verwendung eines Prototyps besteht darin, dass eine Objektinstanz die Eigenschaften und Methoden, die es enthält, teilen kann. Anstatt Definitionsobjektinformationen zum Konstruktor hinzuzufügen, können Sie diese Informationen direkt zum Prototyp hinzufügen. Das Hauptproblem bei der Verwendung von Konstruktoren besteht darin, dass jede Methode in jeder Instanz einmal erstellt werden muss.
In JavaScript gibt es zwei Arten von Werten, ursprüngliche Werte und Objektwerte. Jedes Objekt verfügt über einen internen Eigenschaftsprototyp, den wir normalerweise als Prototyp nennen. Der Wert des Prototyps kann ein Objekt oder ein Null sein. Wenn sein Wert ein Objekt ist, muss das Objekt auch einen eigenen Prototyp haben. Dies bildet eine lineare Kette, die wir die Prototypkette nennen.
Bedeutung
Funktionen können als Konstruktoren verwendet werden. Darüber hinaus hat nur die Funktion ein Prototypattribut und kann zugegriffen werden, aber auf die Objektinstanz hat dieses Attribut nicht, es gibt nur ein internes unzugängliches __Proto__ -Attribut. __Proto__ ist ein mysteriöser Link im Objekt zum entsprechenden Prototyp. Nach dem Standard wird __Proto__ nicht an die Öffentlichkeit weitergegeben, was bedeutet, dass es sich um ein Privateigentum handelt, aber der Motor von Firefox hat es ausgesetzt und wurde zu einem gemeinsamen Eigentum, auf das wir zugreifen und festlegen können.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
var browser = function () {};
Browser.prototype.run = function () {
Alarm ("Ich bin Gecko, ein Kernel von Firefox");
}
var bro = new browser ();
Bro.run ();
</script>
Wenn wir die bro.run () -Methode nennen, da es in Bro keine solche Methode gibt, wird er in seiner __proproto__ dh Browser.Prototyp danach suchen, sodass die Run () -Methode schließlich ausgeführt wird. (Hier repräsentiert der kapitalisierte Buchstaben der Funktion den Konstruktor, um die gewöhnlichen Funktionen zu unterscheiden)
Wenn Sie den Konstruktor aufrufen, um eine Instanz zu erstellen, enthält die Instanz einen internen Zeiger (__Proto__), der auf den Prototyp des Konstruktors hinweist. Diese Verbindung besteht zwischen der Instanz und dem Prototyp des Konstruktors, nicht zwischen der Instanz und dem Konstruktor.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktion Person (Name) {// Konstruktorfunktion
this.name = name;
}
Person.Prototype.printname = function () // Prototyp -Objekt
{
alarm (this.name);
}
var person1 = new Person ('Byron'); // das Objekt instanziieren
console.log (Person1 .__ Proto __); // Person
console.log (Person1.Constructor); // Versuchen Sie es selbst, um zu sehen, was es sein wird
console.log (person.Prototype); // Zeigen Sie auf die Prototyp -Objektperson
var person2 = neue Person ('Frank');
</script>
Die Instanzperson1 der Person enthält das Namensattribut und generiert automatisch ein __Proto__ -Attribut, das auf den Prototyp der Person hinweist, und Sie können auf die im Prototyp definierte PrintName -Methode zugreifen, die wahrscheinlich wie folgt ist:
Jede JavaScript -Funktion hat ein Prototyp -Attribut, das sich auf ein Objekt bezieht, das das Prototypobjekt ist. Das Prototypobjekt ist beim Initialisieren leer. Wir können alle Eigenschaften und Methoden darin anpassen. Diese Methoden und Eigenschaften werden von den vom Konstruktor erstellten Objekten vererbt.
Jetzt ist das Problem. Wie ist die Beziehung zwischen Konstruktor, Instanz und Prototypobjekt?
Der Unterschied zwischen Konstruktoren, Instanzen und Prototypobjekten
Eine Instanz wird durch einen Konstruktor erstellt. Sobald eine Instanz erstellt wurde, hat es das Konstruktorattribut (auf die Konstruktorfunktion hinweist) und das __Proto__ -Attribut (auf das Prototyp -Objekt hinweisen).
Im Konstruktor befindet sich eine Prototyp -Eigenschaft, die ein Zeiger auf sein Prototypobjekt ist.
Es gibt auch einen Zeiger (Konstruktoreigenschaft) im Prototyp -Objekt, der auf den Konstruktor zeigt: Person.Prototyp.Constructor = Person;
Instanzen können auf Eigenschaften und Methoden zugreifen, die im Prototypobjekt definiert sind.
Hier sind Person1 und Person2 Instanzen, und Prototyp sind ihre Prototypobjekte.
Noch eine Kastanie:
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktion Animal (Name) // Konstruktor akkumulieren
{
this.name = name; // Objekteigenschaften festlegen
}
Animal.Prototyp.Behavior = Funktion () // Verhaltensmethode zum Prototyp des Basisklassenkonstruktors hinzufügen
{
alarm ("Dies ist ein"+this.name);
}
var hund = neues Tier ("Hund"); // Hundeobjekt erstellen
var cat = New Animal ("Cat"); // Katzenobjekt erstellen
Hunde
Cat.Behavior (); // Ausgabe "Dies ist eine Katze"
alarm (hund.behavior == Cat.Behavior); // Ausgabe true;
</script>
Aus dem Programm wird ersichtlich, dass die auf dem Prototyp des Konstruktors definierten Methoden tatsächlich über das Objekt direkt aufgerufen werden können, und der Code wird gemeinsam genutzt. (Sie können versuchen, die Prototyp -Eigenschaft in Animal.Prototype.Behavior zu entfernen, um festzustellen, ob sie noch ausgeführt werden kann.) Hier zeigt die Prototyp -Eigenschaft auf das Tierobjekt.
Array -Objektinstanz
Schauen wir uns eine Instanz des Array -Objekts an. Wenn wir das Objektarray1 erstellen, lautet das tatsächliche Objektmodell von Array1 in der JavaScript -Engine wie folgt:
Die Codekopie lautet wie folgt:
var array1 = [1,2,3];
Das Array1 -Objekt hat einen Längenattributwert von 3, aber wir können mit der folgenden Methode Elemente zu Array1 hinzufügen:
Die Codekopie lautet wie folgt:
Array1.push (4);
Die Push -Methode stammt aus einer Methode, die vom __Proto__ -Mitglied von Array1 (Array.Prototye.push ()) auf das Objekt hinweist. Genau daran, dass alle Array -Objekte (erstellt über []) ein __Proto__ -Mitglied enthalten, das auf dasselbe Methodenobjekt mit Push, Reverse usw. zeigt, dass diese Array -Objekte Push-, Reverse- und andere Methoden verwenden können.
Funktionsobjektinstanz
Die Codekopie lautet wie folgt:
Funktion Base () {
this.id = "Base"
}
Die Codekopie lautet wie folgt:
var obj = new base ();
Was ist das Ergebnis eines solchen Codes? Das Objektmodell, das wir in der JavaScript -Engine sehen, lautet:
Was genau hat der neue Betreiber getan? Tatsächlich war es sehr einfach, nur drei Dinge.
Die Codekopie lautet wie folgt:
var obj = {};
obj .__ proto__ = base.Prototyp;
Base.call (obj);
Prototypkette
Prototyp -Kette: Wenn eine Eigenschaft oder Methode aus einem Objekt abgerufen wird, sucht das Objekt selbst keine Eigenschaft oder Methode, die nach dem Prototyp -Objekt sucht, mit dem Sie assoziieren. Wenn es keinen Prototyp gibt, sucht es nach dem Vorgänger des Prototyps, der dem Prototyp zugeordnet ist. Wenn es nicht mehr gibt, suchen Sie weiter nach dem von Prototype.Prototyp verwiesenen Objekt und so weiter, bis der Prototyp ....... Prototyp nicht definiert ist (der Prototyp des Objekts ist undefiniert), wodurch die sogenannte "Prototypkette" gebildet wird.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsform () {
this.name = "form";
this.toString = function () {
kehre diesen namennamen zurück;
}
}
Funktion twoshape () {
this.name = "2 Form";
}
Funktion Dreieck (Seite, Höhe) {
this.name = "Triangle";
this.side = Seite;
this.height = Höhe;
this.getArea = function () {
zurück this.side*this.height/2;
}
}
Twoshape.Prototype = new Shape ();
Triangle.Prototype = new twoshape ();
</script>
Hier wird eine neue Entität mit der Konstruktorform () erstellt und dann verwendet, um den Prototyp des Objekts zu überschreiben.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsform () {
this.name = "form";
this.toString = function () {
kehre diesen namennamen zurück;
}
}
Funktion twoshape () {
this.name = "2 Form";
}
Funktion Dreieck (Seite, Höhe) {
this.name = "Triangle";
this.side = Seite;
this.height = Höhe;
this.getArea = function () {
zurück this.side*this.height/2;
}
}
Twoshape.Prototype = new Shape ();
Triangle.Prototype = new twoshape ();
Twoshape.prototype.constructor = twoshape;
Triangle.Prototype.Constructor = Triangle;
var mein = neues Dreieck (5,10);
my.getArea ();
My.ToString (); // Dreieck
My.Constructor; // Dreieck (Seite, Höhe)
</script>
Prototyp -Vererbung
Prototyp -Vererbung: Am Ende der Prototypkette ist es das Prototyp -Objekt, auf das das Objektkonstruktor -Prototyp -Attribut angezeigt wird. Dieses Prototypobjekt ist der Vorfahr aller Objekte, und dieser Vorfahren hat Methoden implementiert, die alle Objekte wie das Tostring von Natur aus haben sollten. Andere integrierte Konstruktoren wie Funktion, Boolean, String, Datum und Regexp werden von diesem Vorfahren geerbt, aber sie definieren jeweils ihre eigenen Attribute und Methoden, so dass ihre Nachkommen die Eigenschaften ihrer jeweiligen Clans zeigen.
In ECMAScript wird die Methode zur Implementierung der Vererbung erreicht, indem sich auf die Prototypkette stützt.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsbox () {// Die ererbte Funktion heißt SuperType (übergeordnete Klasse, Basisklasse)
this.name = "Jack";
}
Funktionsbaum () {// erbte Funktionen werden als Subtypen bezeichnet (Unterklassen, abgeleitete Klassen)
this.age = 300;
}
// Erben Sie durch Prototypkette die Prototypattribute des Subtyps
// New Box () übergeben die Informationen im Box -Konstrukt und die Informationen im Prototyp zum Baum
Tree.Prototype = new box (); // Treer erbt die Box und bildet eine Kette durch den Prototyp.
var tree = new tree ();
Alert (Tree.Name); // Popt Jack
</script>
Problem mit der Prototypkette: Obwohl die Prototypkette sehr leistungsfähig ist und zur Implementierung der Vererbung verwendet werden kann, hat sie auch einige Probleme. Das wichtigste Problem kommt vom Wertprototyp, der den Referenztyp enthält. Prototypattribute, die Referenztypen enthalten, werden von allen Instanzen gemeinsam genutzt. Aus diesem Grund werden Attribute in Konstruktoren definiert, nicht in Prototypobjekten. Wenn die Vererbung durch einen Prototyp erreicht wird, wird der Prototyp tatsächlich zu einer Instanz eines anderen Typs. Daher wird das ursprüngliche Instanzattribut zum Prototyp -Attribut.
Beim Erstellen einer Instanz eines Subtyps kann das Argument nicht an den Supertyp -Konstruktor übergeben werden. Tatsächlich sollte gesagt werden, dass es keine Möglichkeit gibt, Parameter an den Supertyp -Konstruktor weiterzugeben, ohne alle Objektinstanzen zu beeinflussen. Zusätzlich zu dem Problem, das gerade aufgrund der Einbeziehung von Referenztypwerten in Prototypen diskutiert wurde, ist es selten, Prototypketten allein in der Praxis zu verwenden.
Noch eine Kastanie:
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsperson (Name)
{
this.name = name; // Objekteigenschaften festlegen
};
Person.Prototype.company = "Microsoft"; // Setzen Sie die Eigenschaften des Prototyps
Person.Prototype.sayhello = function () // Prototyp -Methode
{
alert ("Hallo, ich bin"+ this.name+ "von"+ this.comPany);
};
var billgates = neue Person ("Billgates"); // Personalobjekt erstellen
Billgates.sayhello (); // erbt den Inhalt des Prototyps und gibt "Hallo, ich bin Billgates of Microsoft" aus.
var Jobs = neue Person ("Jobs");
Jobs.company = "Apple"; // Legen Sie Ihr eigenes Unternehmensattribut fest, um das Unternehmensattribut des Prototyps zu vertuschen
Jobs.sayhello = function ())
{
alert ("hi", + this.name + "Like" + this.comPany);
};
Jobs.sayhello (); // Die Eigenschaften und Methoden, die Sie selbst überschreiben, geben "Hallo, Jobs wie Apple" aus.
Billgates.sayhello (); // Die Berichterstattung von Arbeitsplätzen wirkt sich nicht auf den Prototyp aus, Billgates gibt immer noch aus
</script>
Siehe das folgende Beispiel der Prototyp -Kette:
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsjahr () {
this.Value = 21;
}
Jahr.Prototype = {
Methode: function () {
}
};
Funktion hi () {
};
// Setzen Sie die Prototypeneigenschaft von HI auf das Instanzobjekt des Jahres
Hi.Prototype = neues Jahr ();
Hi.prototype.year = 'Hallo Welt';
Hi.Prototype.Constructor = hi;
var test = new Hi (); // Erstellen Sie eine neue Instanz von HI
// Prototyp -Kette
testen [hi Beispiel]
Hi.Prototype [Beispiel des Jahres]
{Jahr: 'Hallo Welt'}
Jahr.Prototyp
{Verfahren:…};
Object.Prototyp
{toString: ...};
</script>
Aus dem obigen Beispiel wird das Testobjekt von Hi.Prototype und Year.Prototype geerbt; Daher kann es zugreifen
__ptoto__ Attribut
Das __ptoto__ -Attribut (nicht vom IE -Browser unterstützt) ist ein Zeiger auf das Prototypobjekt der Instanz. Seine Funktion besteht darin, auf den Prototyp -Attributkonstruktor des Konstruktors zu verweisen. Durch diese beiden Attribute können Sie auf die Eigenschaften und Methoden im Prototyp zugreifen.
Eine Objektinstanz in JavaScript besteht im Wesentlichen aus einer Reihe von Eigenschaften. Unter diesen Immobilien gibt es eine intern unsichtbare Sondereigenschaft - __Proto__. Der Wert dieser Eigenschaft zeigt auf den Prototyp der Objektinstanz. Eine Objektinstanz hat nur einen einzigartigen Prototyp.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsbox () {// Großbuchstaben, die den Konstruktor darstellt
Box.prototype.name = "trigkit4"; // Prototyp -Attribute
Box.prototype.age = "21";
Box.prototype.run = function () // Prototyp -Methode
{
kehre this.name + this.age + 'studieren';
}
}
var box1 = new box ();
var box2 = new box ();
ALERT (Box1.Constructor); // Konstruieren Sie das Attribut, Sie können den Konstruktor selbst erhalten.
// Die Funktion soll durch den Prototypzeiger positioniert werden und dann den Konstruktor selbst erhalten
</script>
Der Unterschied zwischen __Proto__ Attribut und Prototypattribut
Prototyp ist eine proprietäre Eigenschaft im Funktionsobjekt.
__Proto__ ist eine implizite Eigenschaft eines normalen Objekts. Wenn neu, zeigt es auf das von Prototyp hingewiesene Objekt;
__ptoto__ ist tatsächlich ein Attribut eines bestimmten Entitätsobjekts, während Prototyp ein Attribut des Konstruktors ist. __ptoto__ kann nur in Lern- oder Debugging -Umgebungen verwendet werden.
Ausführungsprozess für Prototypenmodus
1. Suchen Sie zuerst nach den Attributen oder Methoden in der Konstruktorinstanz und kehren Sie, falls ja, sofort zurück.
2. Wenn es keine Instanz des Konstruktors gibt, gehen Sie zu seinem Prototypobjekt und kehren Sie sofort zurück.
Prototypobjekt
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsbox () {// Großbuchstaben, die den Konstruktor darstellt
Box.prototype.name = "trigkit4"; // Prototyp -Attribute
Box.prototype.age = "21";
Box.prototype.run = function () // Prototyp -Methode
{
kehre this.name + this.age + 'studieren';
}
}
var box1 = new box ();
Alert (Box1.Name); // Trigkit4, der Wert im Prototyp
Box1.Name = "Lee";
Alert (Box1.Name); // Lee, gehen Sie zum Prinzip
var box2 = new box ();
Alert (box2.name); // trigkit4, der Wert des Prototyps, nicht durch Box1 geändert
</script>
Der Konstruktor des Konstruktors
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsbox () {
this.name = "bill";
}
Box.prototype.name = "trigkit4"; // Prototyp -Attribute
Box.prototype.age = "21";
Box.prototype.run = function () // Prototyp -Methode
{
kehre this.name + this.age + 'studieren';
}
var box1 = new box ();
Alert (Box1.Name); // Bill, der Wert im Prototyp
Box1.Name = "Lee";
Alert (Box1.Name); // Lee, gehen Sie zum Prinzip
</script>
Zusammenfassend lassen Sie uns dies aussortieren:
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktion person () {};
Person.Prototype.name = "trigkit4";
Person.Prototype.say = function () {
alarm ("hi");
}
var p1 = new Person (); // Prototyp ist ein Prototypobjekt von P1 und P2
var p2 = new Person (); // p2 ist ein instanziiertes Objekt, und es gibt ein __Proto__ -Attribut darin, das auf den Prototyp einer Person hinweist
console.log (p1.prototype); // undefined ist diese Eigenschaft ein Objekt und kann nicht zugegriffen werden
console.log (Person.Prototype); // Person
console.log (person.prototype.constructor); // Es gibt auch eine Zeigerin (Konstruktoreigenschaft) innerhalb des Prototyp -Objekts, das auf die Konstruktorfunktion hinweist
console.log (p1 .__ proto __); // Diese Eigenschaft ist ein Zeiger, der auf das Prototyp -Objekt des Prototyps zeigt
p1.say (); // Instanzen können auf Eigenschaften und Methoden zugreifen, die im Prototyp -Objekt definiert sind
</script>
Fabrikmodell
Die Codekopie lautet wie folgt:
Funktion createObject (Name, Alter) {
var obj = neues Objekt ();
obj.name = name;
obj.age = Alter;
Rückkehr obj;
}
Das Fabrikmuster löst das Problem der großräumigen Duplikation instanziierter Objekte, aber es gibt ein anderes Problem, dh es ist unmöglich herauszufinden, welche Instanz des Objekts sie sind.
Die Verwendung der Konstruktormethode löst nicht nur das Problem der wiederholten Instanziierung, sondern auch das Problem der Objekterkennung.
Der Unterschied zwischen der Verwendung von Konstruktormethoden und Fabrikmustern besteht darin, dass:
1. erstellen Objekt (neues Objekt ()), das nicht von der Konstruktor -Methode angezeigt wird;
2. Weisen Sie diesem Objekt direkt Attribute und Methoden zu
3. Keine Rückgabeerklärung
Wenn der Konstruktor verwendet wird und der neue Konstruktor () verwendet wird, wird ein neues Objekt () im Hintergrund ausgeführt.
Dies repräsentiert in der Funktionskörper das von einem neue Objekt abgeleitete Objekt ()
1. Bestimmen Sie, ob sich die Eigenschaft in der Konstruktorinstanz oder im Prototyp befindet, Sie können die Funktion "HasownProperty ()" "verwenden
2. Die Art und Weise, wie Literale erstellt werden, wird verwendet, um Konstruktorattribute zu erstellen, nicht auf die Instanz, sondern auf das Objekt, und die Art und Weise, Konstruktoren zu erstellen, ist das Gegenteil.
Warum auf Objekt hinweisen? Weil Box.Prototype = {}; diese Art des Schreibens ist tatsächlich, ein neues Objekt zu erstellen.
Jedes Mal, wenn eine Funktion erstellt wird, wird ihr Prototyp gleichzeitig erstellt, und dieses Objekt erhält automatisch das Konstruktorattribut
3. Wenn es sich um eine Instanzmethode handelt, sind ihre Methodenadressen unterschiedlich und einzigartig.
4. Wenn es sich um eine Prototypmethode handelt, wird ihre Adresse geteilt