Wir wissen, dass der Operator „instanceof“ verwendet wird, um zu prüfen, ob ein Objekt eine Instanz eines Konstruktors ist. Die verschiedenen Szenarien, in denen „true“ zurückgegeben wird, sind unten aufgeführt.
1. Das Objekt obj wird durch einen neuen Konstruktor erstellt, dann ist die obj-Instanz des Konstruktors wahr
Kopieren Sie den Codecode wie folgt:
Funktion Person(n, a) {
this.name = n;
this.age = a;
}
var p = neue Person('John Backus', 82);
console.log(p-Instanz von Person); // true
2. Wenn eine Vererbungsbeziehung besteht, geben die Instanzen der Unterklasse und der übergeordneten Klasse ebenfalls true zurück.
Kopieren Sie den Codecode wie folgt:
Funktion A(){}
Funktion B(){}
B.prototype = new A(); // B erbt von A
var b = neues B();
console.log(b Instanz von A); // true
3. Da Object die Stammklasse ist, erben alle anderen benutzerdefinierten Klassen von ihr, sodass die Instanz von Object eines beliebigen Konstruktors true zurückgibt.
Kopieren Sie den Codecode wie folgt:
Funktion A() {}
var a = neues A();
console.log(eine Instanz von Object); // true
var str = new String('hello');
console.log(str Instanz des Objekts); // true
var num = neue Zahl(1);
console.log(num Instanz des Objekts); // true
Sogar der Konstrukteur selbst
Kopieren Sie den Codecode wie folgt:
Funktion A() {}
console.log(Eine Instanz von Object); // true
console.log(String instanceof Object); // true
console.log(Anzahl der Objektinstanzen); // true
4. Alle Konstruktorinstanzen der Funktion geben true zurück
Kopieren Sie den Codecode wie folgt:
Funktion A() {}
console.log(Eine Instanz der Funktion); // true
console.log(String instanceof Function); // true
console.log(Anzahl der Funktionsinstanzen); // true
Die oben genannten vier Punkte werden in einem Satz zusammengefasst: Wenn eine Instanz von einer bestimmten Klasse oder ihrer Unterklasse erstellt wird, gibt „instanceof“ „true“ zurück. Oder wenn der Prototyp eines bestimmten Konstruktors in der internen Prototypenkette des Objekts obj vorhanden ist, wird true zurückgegeben. Das heißt, das Ergebnis von „instanceof“ hat keine direkte Beziehung zum Konstruktor selbst. Dies ist in vielen Sprachen üblich.
In Java ist eine Klasse Person definiert, und Instanz p gibt sowohl für Person als auch für Objekt „true“ zurück.
Kopieren Sie den Codecode wie folgt:
Klasse Person {
öffentlicher String-Name;
öffentliches Int-Alter;
Person (String n, int a) {
this.name = Name;
this.age = a;
}
public static void main(String[] args) {
Person p = neue Person("John Backus", 82);
System.out.println(p instanceof Person); // true
System.out.println(p instanceof Object); // true
}
}
Wenn in Java eine Vererbungsbeziehung besteht, gibt die Instanz der übergeordneten Klasse der Unterklasse ebenfalls true zurück.
Kopieren Sie den Codecode wie folgt:
// übergeordnete Klasse
Klasse Person {
öffentlicher String-Name;
öffentliches Int-Alter;
Person (String n, int a) {
Name = Name;
Alter = a;
}
}
// Unterklasse
öffentliche Klasse Man erweitert Person{
öffentliche String-Universität;
Man(String n, int a, String s) {
super(n, a);
Universität = s;
}
public static void main(String[] args) {
Man mm = new Man("John Resig", 29, "PKU");
System.out.println(mm instanceof Man); // true
System.out.println(mm instanceof Person); // auch wahr
}
}
Vor diesem Hintergrund ist die folgende Leistung in JS nicht überraschend
Kopieren Sie den Codecode wie folgt:
//Definiere zwei Konstruktoren
Funktion A(){}
Funktion B(){}
A.prototype = B.prototype = {a: 1};
//Erstelle jeweils zwei Instanzen unterschiedlicher Konstruktoren
var a = neues A();
var b = neues B();
console.log(eine Instanz von B); // true
console.log(b Instanz von A); // true
Wir sehen, dass a und b mit A bzw. B erstellt werden, aber sowohl eine Instanz von B als auch eine Instanz von A sind wahr. Das heißt, obwohl a nicht mit Konstruktor B erstellt wird, gibt es dennoch true zurück. Weil B.prototype in der internen Prototypenkette von a existiert.
Aufgrund der dynamischen Spracheigenschaften von JS kann der Prototyp zur Laufzeit geändert werden, sodass es nicht verwunderlich ist, dass das Folgende false zurückgibt. Da sich A.prototype nicht mehr in der internen Prototypenkette von a befindet, ist die Kette unterbrochen.
Kopieren Sie den Codecode wie folgt:
Funktion A(){}
var a = neues A();
A.prototype = {}; // Den Prototyp dynamisch ändern. Bitte beachten Sie, dass dies nach dem Erstellen eines erfolgen muss
console.log(eine Instanz von A); // false
Beachten Sie, dass durch das Schreiben auch der erste oben zusammengefasste Punkt zunichte gemacht wird: Das Objekt obj wird durch den neuen Konstruktor erstellt, dann ist die obj-Instanz des Konstruktors wahr
Tatsächlich ruft die interne Implementierung von „instanceof“ im ECMAScript-Standard (vorbehaltlich 5.1) die interne Methode [[HasInstance]] des Konstruktors auf, die wie folgt beschrieben wird
Wenn F ein Funktionsobjekt ist, werden bei der Ausführung von F(V) die folgenden Schritte ausgeführt:
1. Wenn der linke Operand V der Instanz von kein Objekttyp ist, geben Sie direkt false zurück.
Kopieren Sie den Codecode wie folgt:
var a, b = 1, c = wahr, d = 'Hallo';
console.log(eine Instanz von Object); // false hier ist ein Wert undefiniert
console.log(b instanceof Object); // false
console.log(c instanceof Object); // false
console.log(d Instanz des Objekts); // false
2/3. Rufen Sie das Prototypattribut des Konstruktors F ab. Wenn es sich nicht um einen Objekttyp handelt, muss eine TypeError-Ausnahme ausgelöst werden.
Kopieren Sie den Codecode wie folgt:
Funktion A(){}
A.prototype = 1; // Den Prototyp von A auf einen Nicht-Objekttyp setzen
var a = neues A();
console.log(eine Instanz von A);
Die von jedem Browser ausgelösten Ausnahmeaufforderungen sind unterschiedlich.
Firefox18:
Chrome24:
Safari6:
Opera12:
IE10:
4. Führen Sie kontinuierlich die folgende Logik aus: Setzen Sie V auf das V des internen Prototyps, geben Sie false zurück, wenn V null ist, und geben Sie true zurück, wenn sowohl V als auch O auf dasselbe Objekt zeigen.