Beispiele erläutern die Verwendung des Instanzoperators in JavaScript

Einführung in den Instanz des Operators

In JavaScript verwenden Sie den Typ -Operator. Wenn Sie den TypeOF -Operator verwenden, haben Sie ein Problem mit einem Referenztyp, um den Wert zu speichern. Unabhängig davon, auf welche Art von Objekt referenziert wird, gibt es "Objekt" zurück. ECMAScript führt eine weitere Instanz des Java -Operators vor, um dieses Problem zu lösen. Der Instanzoperator ähnelt dem Typtyp -Operator und wird verwendet, um den Typ des zu verarbeitenden Objekts zu identifizieren. Im Gegensatz zur TypeOF -Methode muss der Entwickler die Instanzmethode explizit bestätigen, dass das Objekt ein spezifischer Typ ist. Zum Beispiel:

Auflistung 1. Instanz des Beispiels

 var ostringObject = new String ("Hallo Welt"); console.log (ostringObject Instance von String); // Ausgabe "true"

In diesem Code wird gefragt: "Ist die variable ostringObject eine Instanz des String -Objekts?" OstringObject ist in der Tat eine Instanz des String -Objekts, daher ist das Ergebnis "wahr". Obwohl die Instanzmethode nicht so flexibel ist wie die TypeOF -Methode, ist sie nützlich, wenn die TypeOF -Methode "Objekt" zurückgibt.

Allgemeine Verwendung des Instanzbetreibers:

Im Allgemeinen besteht die Verwendung von Instanzen von der Verwendung fest, ob eine Instanz zu einem bestimmten Typ gehört. Zum Beispiel:

Auflistung 2. Allgemeine Nutzung von Instanzen von

 // Bestimmen Sie, ob foo eine Instanz der Foo -Klasse -Funktion ist foo () {} var foo = new foo (); console.log (foo instanceof foo) // true

Darüber hinaus ist ein stärkerer Punkt, dass Instanz in Erbbeziehungen verwendet werden kann, um festzustellen, ob eine Instanz zu ihrem übergeordneten Typ gehört. Zum Beispiel:

Auflistung 3. Nutzung von Instanz in Erbschaftsbeziehungen

 // Bestimmen Sie, ob FOO eine Instanz der Foo -Klasse ist und ob es sich um eine Instanz seiner übergeordneten Typ -Funktion aoo () {} Funktion foo () {} foo.prototype = new aoo (); // Javascript -Prototyp -Vererbung var foo = new foo (); console.log (foo instanceof foo) // true console.log (foo instanceof aoo) // true

Im obigen Code wird die übergeordnete Klasse in einer Schicht Erbschaftsbeziehung beurteilt. In der mehrschichtigen Erbschaftsbeziehung ist auch der Instanzbetreiber anwendbar.

Verstehen Sie den Instanz des Operators wirklich?

Denken Sie nach dem Lesen des oben genannten Code -Beispiels den Instanz des Operators sehr einfach? Schauen wir uns einen komplizierten Gebrauch an.

Listing 4. Instanz der komplexen Verwendung

 console.log (ObjectinstanceOf -Objekt); // True Console.log (Funktionsinstanzfunktion); // True Console.log (Nummerinstanznummer); // false console.log (String -Instanz von String); // false console.log (Funktion InstanceOF -Objekt); // true console.log (foo InstanceOf function); // echte console.Log (foo Infance);

Sind Sie nach dem Lesen des obigen Code wieder verwirrt? Warum sind Objekt- und Funktionsinstanzen gleich wahr, während andere Instanzen selbst nicht gleich wahr sind? Wie kann man es erklären? Um das Geheimnis der Instanz grundlegend zu verstehen, müssen wir von zwei Aspekten beginnen: 1. So definieren Sie diesen Operator in der Sprachspezifikation. 2. JavaScript -Prototyp -Vererbungsmechanismus.

Auflistung 5. JavaScript -Instanz des Bedienungscode

 Funktionsinstance_of (l, r) {// l repräsentiert den linken Expression, R repräsentiert den rechten Ausdruck var o = r.Prototyp; // Nehmen Sie den Anzeigeprototyp von r = l .__ Proto __; // Nehmen Sie den impliziten Prototyp von l while (true) {if (l === null) return falsch; if (o === l) // Hier ist der Punkt: Wenn O streng gleich l gleich ist, kehren Sie wahr zurück; L = l .__ proto__; }}

Listing 6. Objektinstanz des Objekts

 // Unterscheidet zum Ausdruck des Expression zunächst zwischen dem linken Expression und dem rechten Expression Objectl = Object, Objectr = Objekt; // Folgendes ist die allmähliche Abgabe von o = objectr.Prototype = Object.Prototype L = Objectl .__ proto__ = function.prototype // Das erste Urteil ist o! = L // Schleife, um zu finden, ob l noch __Proto__ l = Funktion.Prototype. __ proto__ = Object.ProTotype // Das zweite Urteilsurteil hat das zweite Beurteil

Listing 7. Funktionsinstanz der Funktion

 // Unterscheidet zuerst zwischen dem linken Expression und der rechten Expression funktionl = Funktion, FunktionR = Funktion; // Folgendes ist die schrittweise abzuleiten o = functionR.Prototype = function.prototype l = functionl .__ proto__ = function

Listing 8. Foo Instanz von Foo

 // Unterscheiden Sie zum Ausdruck des Ausdrucks zunächst zwischen dem linken Ausdruck und dem rechten Ausdruck Fool = foo, foor = foo; // Folgendes ist nach allmählich nach den Spezifikationen o = foor.prototype = foo.Prototyp L = Fool .__ proto__ = Funktion.Prototyp // Das erste Urteil ist o! = L // Das erste Urteil ist o! = L // Der Zyklus ist, ob l immer noch __Proto__ l = prototype. ist herauszufinden, ob l immer noch __Proto__ l = Object.Prototype .__ proto__ = null // Das dritte Urteil L == NULL // Falsch zurückgeben

Analysieren Sie kurz die Anwendung von Instanz im Dojo -Vererbungsmechanismus

In JavaScript gibt es kein Konzept der multiplen Erbschaft, genau wie Java. Bei der Erklärung von Klassen in DOJO ist jedoch die Vererbung aus mehreren Klassen zulässig. Nehmen wir dojo 1.6.1 als Beispiel.

Auflistung 9. Mehrfacher Erbe in Dojo

 dojo.declare ("aoo", null, {}); dojo.declare ("boo", null, {}); dojo.declare ("foo", [aoo, boo], {}); var foo = new foo (); console.log (foo instanceof aoo); // true console.log (foo instanceof boo); // false console.log (foo.issinstanceof (aoo); // True Console.log (foo.issinstanceof (boo); // True console.log (foo.issinstance (boosinstance (boo));

Im obigen Beispiel erbt Foo sowohl von AOO als auch von Boo, aber wenn er den Instanz des Operators verwendet, um zu überprüfen, ob Foo eine Instanz von Boo ist, gibt es falsche zurück. In der Tat erbt Foo im DOJO immer noch nur von AOO und verwendet den Mixin -Mechanismus, um die Methoden und Eigenschaften in der Boo -Klasse zu foo zu kopieren. Wenn der Instanz des Operators verwendet wird, um zu prüfen, ob es sich um eine Instanz von Boo handelt, wird FALSE zurückgegeben. Daher fügt Dojo eine neue Methode, die als ISInstanceOF für jede Klasse -Instanz namens namens namens, hinzu und verwendet diese Methode, um mehrere Vererben zu überprüfen.