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">
Funktionstest () {
var color = "blau"; // Private Variable
var fn = function () // Private Funktion
{
}
}
</script>
Auf diese Weise können die Variablen Farbe und FN nicht außerhalb des Funktionsobjekttests zugegriffen werden und werden privat:
Die Codekopie lautet wie folgt:
var obj = neuer Test ();
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. JavaScript kann dies auch tun
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktion obj () {
this.a = []; // Instanzvariable
this.fn = function () {// Instanzmethode
}
}
console.log (typeof obj.a); //undefiniert
console.log (typeof obj.fn); //undefiniert
var o = neuer obj ();
console.log (typeof oa); //Objekt
console.log (typeof o.fn); //Funktion
</script>
Fügen Sie den Instanzvariablen und -Methoden neue Methoden und Eigenschaften hinzu
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktion obj () {
this.a = []; // Instanzvariable
this.fn = function () {// Instanzmethode
}
}
var o1 = neuer obj ();
O1.A.PUSH (1);
o1.fn = {};
console.log (o1.a); // [1]
console.log (typeof o1.fn); //Objekt
var o2 = neuer obj ();
console.log (o2.a); // []
console.log (typeof o2.fn); //Funktion
</script>
A und FN werden in O1 modifiziert, jedoch nicht in O2. Da Arrays und Funktionen Objekte und Referenztypen sind, bedeutet dies, dass die Eigenschaften und Methoden in O1, obwohl sie in O2 die gleichen sind, jedoch keine Referenz sind, sondern eine Kopie der Eigenschaften und Methoden, die vom OBJ -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">
Funktionsperson (Name) {
this.name = name;
}
Person.Prototype.printname = function () {
alarm (this.name);
}
var person1 = neue Person ('Byron');
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:
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:
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>