Heim > Artikel > Web-Frontend > Einführung in den Unterschied zwischen „typeof“ und „instanceof“ in JavaScript (Codebeispiel)
Dieser Artikel bietet Ihnen eine Einführung in den Unterschied zwischen „typeof“ und „instanceof“ in JavaScript. Ich hoffe, dass er für Freunde hilfreich ist.
Typeof und Instanzof werden in JavaScript häufig verwendet, um festzustellen, ob eine Variable leer ist oder welchen Typ sie hat. Aber es gibt immer noch Unterschiede zwischen ihnen:
typeof
typeof ist eine unäre Operation, die vor einem Operanden platziert wird, und der Operand kann von jedem beliebigen Typ sein.
Es wird eine Zeichenfolge zurückgegeben, die den Typ des Operanden beschreibt. (Der Operator „typeof“ gibt eine Zeichenfolge zurück, die zur Darstellung des Datentyps des Ausdrucks verwendet wird.)
typeof ist eigentlich eine Instanz zur Bestimmung des Typs des Parameters. Nur ein Parameter
typeof kann im Allgemeinen nur return Die folgenden Ergebnisse: „Zahl“, „Zeichenfolge“, „boolean“, „Objekt“, „Funktion“ und „undefiniert“.
Der Operand ist eine Zahl typeof(x) = "number"
String typeof(x) = "string"
Boolescher Wert typeof(x) = "boolean"
Objekt, Array und Null typeof(x) = "object"
Funktion typeof(x) = "function"
console.log(typeof (123));//typeof(123)返回"number" console.log(typeof ("123"));//typeof("123")返回"string" var param1 = "string"; var param2 = new Object(); var param3 = 10; console.log(typeof(param1)+"\n"+typeof(param2)+"\n"+typeof(param3)); // string object number
Wir können typeof verwenden, um zu ermitteln, ob eine Variable vorhanden ist existiert, wie zum Beispiel if(typeof a!="undefined"){alert("ok")}, verwenden Sie if(a) nicht, denn wenn a nicht existiert (nicht deklariert), tritt ein Fehler auf. Für spezielle Objekte wie Array und Null Die Verwendung von typeof gibt immer ein Objekt zurück. Dies ist die Einschränkung von typeof.
Arrays werden häufig in js verwendet, z. B. mehrere Eingaben mit demselben Namen. Wenn sie dynamisch generiert werden, müssen Sie beim Senden feststellen, ob es sich um Arrays handelt.
if(document.mylist.length != "undefined" ) {} //这个用法有误. 正确的是 `if( typeof(document.mylist.length) != "undefined" ) {}` 或 `if( !isNaN(document.mylist.length) ) {}`
Der Operand von typeof ist keine Definition, der zurückgegebene Wert ist „undefiniert“.
In JavaScript werden Sie versuchen, den Typ einer Variablen mit dem Typeof-Operator zu bestimmen. Bei der Verwendung des Typeof-Operators tritt ein Problem bei der Verwendung von Referenzen auf Typen zum Speichern von Werten Unabhängig von der Referenz Egal um welchen Objekttyp es sich handelt, es wird „Objekt“ zurückgegeben. Dies erfordert, dass Instanzen erkennen, ob ein Objekt eine Instanz eines anderen Objekts ist.
instanceof
Der Instanzof-Operator wird verwendet, um zu testen, ob ein Objekt das Prototypattribut eines Konstruktors in seiner Prototypkette hat.
Syntax: Objektinstanz des Konstruktors
Parameter: Objekt (zu erkennendes Objekt) Konstruktor (ein Konstruktor)
Beschreibung: Der Operator „Instanz des Konstruktors“ wird verwendet, um zu erkennen, ob „constructor.prototype“ im Parameterobjekt vorhanden ist die Prototypenkette.
Instanz: Instanz, Beispiel
eine Instanz von b?alert("true"):alert("false"); //a ist eine Instanz von b? Wahr: Falsch
instanceof wird verwendet, um zu bestimmen, ob eine Variable eine Instanz eines Objekts ist,
如 :var a=new Array(); alert(a instanceof Array); // true, 同时 alert(a instanceof Object) //也会返回 true; 这是因为 Array 是 object 的子类。 再如:function test(){}; var a=new test(); alert(a instanceof test) 会返回true alert(a==b); //flase
Fall:
另外,更重的一点是 `instanceof` 可以在继承关系中用来判断一个实例是否属于它的父类型。 例如: function Foo(){} Foo.prototype = new Aoo();//JavaScript 原型继承 var foo = new Foo(); console.log(foo instanceof Foo)//true console.log(foo instanceof Aoo)//true 上面的代码中是判断了一层继承关系中的父类,在多层继承关系中,instanceof 运算符同样适用。 又如: console.log(Object instanceof Object);//true console.log(Function instanceof Function);//true console.log(Number instanceof Number);//false console.log(String instanceof String);//false console.log(Function instanceof Object);//true console.log(Foo instanceof Function);//true console.log(Foo instanceof Foo);//false
// 定义构造函数 function C(){} function D(){} var o = new C(); // true,因为 Object.getPrototypeOf(o) === C.prototype o instanceof C; // false,因为 D.prototype不在o的原型链上 o instanceof D; o instanceof Object; // true,因为Object.prototype.isPrototypeOf(o)返回true C.prototype instanceof Object // true,同上 C.prototype = {}; var o2 = new C(); o2 instanceof C; // true o instanceof C; // false,C.prototype指向了一个空对象,这个空对象不在o的原型链上. D.prototype = new C(); // 继承 var o3 = new D(); o3 instanceof D; // true o3 instanceof C; // true
Wenn es um „instanceof“ geht, müssen wir einfügen Noch eine Frage, nämlich die Funktion Argumente. Wir denken vielleicht alle, dass Argumente ein Array sind, aber wenn Sie zum Testen die Instanz von verwenden, werden Sie feststellen, dass Argumente kein Array-Objekt sind, auch wenn es ähnlich aussieht.
Außerdem:
Testen Sie var a=new Array();if (eine Instanz eines Objekts) Alert('Y');else Alert('N');
Habe 'Y'
aber wenn (Fensterinstanz des Objekts) Alert('Y');else Alert('N');
bekam 'N'
Also, Das hier von der Instanz von getestete Objekt bezieht sich auf das Objekt in der JS-Syntax, nicht auf das Dom-Modellobjekt.
Es gibt einige Unterschiede bei der Verwendung von typeof
alert(typeof(window)) will get object
Es sollte beachtet werden, dass, wenn der Ausdruck obj instanceof Foo true zurückgibt, Dies bedeutet nicht, dass der Ausdruck immer true zurückgibt, da sich der Wert des Foo.prototype-Attributs ändern kann und der geänderte Wert möglicherweise nicht in der Prototypenkette von obj vorhanden ist. In diesem Fall wird der Wert des ursprünglichen Ausdrucks zurückgegeben falsch werden. In einem anderen Fall ändert sich auch der Wert des ursprünglichen Ausdrucks, dh die Prototypkette des Objekts obj wird geändert. In der aktuellen ES-Spezifikation können wir zwar nur den Prototyp des Objekts lesen, ihn aber nicht ändern Mithilfe von nicht standardmäßigen __proto__-Magieeigenschaften sind erreichbar. Nach der Ausführung von obj.__proto__ = {} gibt die obj-Instanz von Foo beispielsweise false zurück.
Beispiel: Zeigen Sie, dass String-Objekte und Date-Objekte beide zum Objekttyp gehören.
Der folgende Code verwendet „instanceof“, um zu beweisen, dass String- und Date-Objekte ebenfalls zum Objekttyp gehören.
例子: 表明String对象和Date对象都属于Object类型 下面的代码使用了instanceof来证明:String和Date对象同时也属于Object类型。 var simpleStr = "This is a simple string"; var myString = new String(); var newStr = new String("String created with constructor"); var myDate = new Date(); var myObj = {}; simpleStr instanceof String; // returns false, 检查原型链会找到 undefined myString instanceof String; // returns true newStr instanceof String; // returns true myString instanceof Object; // returns true myObj instanceof Object; // returns true, despite an undefined prototype ({}) instanceof Object; // returns true, 同上 myString instanceof Date; // returns false myDate instanceof Date; // returns true myDate instanceof Object; // returns true myDate instanceof String; // returns false
Das obige ist der detaillierte Inhalt vonEinführung in den Unterschied zwischen „typeof“ und „instanceof“ in JavaScript (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!