JavaScript bestimmt den Typ des Objekts

Zusammenfassend gibt es vier Hauptmethoden, um den Typ eines Objekts zu bestimmen: Konstruktorattribut, Typeof-Operator, Instanzof-Operator und Object.prototype.toString()-Methode.

Konstruktorattribut

Konstruktor Das vordefinierte Konstruktorattribut ist der Konstruktor selbst.

var Foo = function(){};
Foo.prototype.constructor === Foo;//true Das durch den Aufruf des Konstruktors über new generierte Objekt basiert auf dem Prototypattribut von der Konstrukteur. Obwohl es in JavaScript kein Klassenkonzept gibt, ähnelt die Funktion eines Konstruktors der ähnlicher Namen und ist ein Bezeichner des Objekttyps. Sie können den Typ des Objekts anzeigen, indem Sie auf die vom Objekt geerbte Konstruktoreigenschaft zugreifen. Variablen vom Typ Primitiv können auch auf die Eigenschaft „Konstruktor“ zugreifen, da JavaScript beim Zugriff ein Wrapper-Objekt bildet.

1 //Basisobjekte
2 var obj = {name: "obj"};
3 obj.constructor === Object;//true
4
5 //selbst definierte „Klasse“
6 var Foo = function(){};
7 var f = new Foo();
8 f.constructor === Foo;//true
9
10 //primitive Typen
11 //Nummer
12 var num = 1;
13 num.constructor === Number;//true
14 var nan = NaN ;
15 nan.constructor === Number;//true
16 //Boolean
17 var b = true;
18 b.constructor === Boolean;//true
19 //String
20 var s = "string";
21 s.constructor === String;//true
22 //Function
23 var Fun =function(){};
24 Fun.constructor === Function;//true; Das Konstruktorattribut kann jedoch kopiert oder überschrieben werden, was zu Fehlern bei der Typbeurteilung führt. Auch wenn wir der Konstruktor-Eigenschaft im Allgemeinen nicht absichtlich einen Wert zuweisen, gibt es Fälle, in denen der Wert der Konstruktor-Eigenschaft von dem abweicht, was wir erwarten. Schauen Sie sich das folgende Beispiel an:

var baseClass = function(){};
var derivativeClass = function(){};
derivedClass.prototype = new baseClass();

var obj = new derivativeClass();
obj.constructor === derivativeClass;//false;
obj.constructor === baseClass;//true; weil der Prototyp der Unterklasse ein ist Die Instanz der übergeordneten Klasse ist ein Prototyp, daher ist der Zugriff auf den Konstruktor über die Instanz der Unterklasse der Konstruktor der übergeordneten Klasse. Daher werden wir in der objektorientierten JavaScript-Programmierung einen Code hinzufügen, um das Konstruktorattribut beim Definieren der Unterklasse zu korrigieren.

derivedClass.prototype.constructor = derivativeClass; Obwohl es praktisch ist, den Konstruktor zur Bestimmung des Variablentyps zu verwenden, ist dies nicht unbedingt besonders sicher, daher müssen Sie vorsichtig sein.

Frame- und fensterübergreifende Probleme:

Wenn Sie den Typ von Objekten aus verschiedenen Frames oder Variablen aus verschiedenen Fenstern bestimmen, funktioniert das Konstruktorattribut nicht richtig. Weil die Kerntypen verschiedener Fenster unterschiedlich sind [1].

Verwenden Sie den „Instanceof“-Operator.

Der „Instanceof“-Operator bestimmt, ob in der Prototypenkette eines Objekts ein Prototypattribut eines Konstruktors vorhanden ist [2]. Das Konzept der Prototypenkette kann in JavaScript Object-Oriented Programming (1) Prototype and Inheritance nachgelesen werden. Der folgende Code bildet die Prototypenkette obj1->derivedClass.prototype->baseClass.prototype->...->Object.prototype. Object.prototype ist der Prototyp aller Objekte, jedeObj-Instanz von Object === true.

var baseClass = function(){};
var derivativeClass = function(){};
derivedClass.prototype = new baseClass();//Vererbung verwenden

var obj1 = new abgeleiteteKlasse();
obj1 Instanz von Basisklasse;//true
obj1 Instanz von abgeleiteter Klasse;//wahr
obj1 Instanz von Objekt;//wahr

obj2 = Objekt. create(derivedClass.prototype);
obj2 Instanz von BaseClass;//true
obj2 Instanz von abgeleiteterKlasse;//true
obj2 Instanz von Object;//true Das Konstruktorattribut kann auf primitive Typen außer null und undefiniert (Zahl) angewendet werden , Zeichenfolge, boolescher Typ). Instanceof funktioniert nicht, aber Sie können die Methode zum Verpacken von Objekten zur Beurteilung verwenden.

3 Instanz von Number // false
'abc' Instanz von String // falsch
true Instanz von Boolean // falsch

new Number(3) Instanz von Number // true
new String('abc') Instanzof String //true
neue Boolean(true) Instanzof Boolean //true Instanceof funktioniert jedoch in Cross-Frame- und Cross-Window-Situationen nicht ordnungsgemäß.

Verwenden Sie die Methode Object.prototype.toString()

Die Methode Object.prototype.toString() ist eine Low-Level-Methode, die eine Zeichenfolge zurückgeben kann, die den Typ des Objekts angibt. Es kann auch verwendet werden, um null und undefiniert zu bestimmen. Die häufigsten Typen sind unten aufgeführt.

Object.prototype.toString.call(3);//"[object Number]"
Object.prototype.toString.call(NaN);//"[object Number]"
Object.prototype.toString.call([1,2,3]);//"[object Array]"
Object.prototype.toString.call(true);//"[object Boolean]"
Object.prototype.toString.call("abc");//"[object String]"
Object.prototype.toString.call(/[a-z]/);//"[object RegExp]"
Object.prototype.toString.call(function(){});//"[object Function]"

//null und undefiniert in Chrome und Firefox. toString.call(undefiniert);//"[object Undefiniert]"

//selbstdefinierte Objekte

var a = new Foo();

Object.prototype.toString.call(a) ;//"[object Object]"

//Typed Wrappers

var b = new Boolean(true);

Object.prototype.toString.call(b);//"[object Boolean]"
var n = new Number(1);
Object.prototype.toString.call(n);//"[object Number]"
var s = new String("abc") ;
Object.prototype.toString.call(s);//"[object String]" verwendet häufig die Slice-Methode, um die Typinformationen im Ergebnis abzufangen:

Object.prototype. toString. call("abc").slice(8,-1);//"String" verwendet den Typeof-Operator

, der ausführlich in einem MDN-Dokument eingeführt wurde [3]. Typeof kann weniger Informationen zurückgeben, einschließlich „undefiniert“, „Objekt“, „Boolescher Wert“, „Zahl“, „Zeichenfolge“, „Funktion“ und „XML“.

Typergebnis

Undefiniert „undefiniert“

Null „Objekt“
Boolean „boolean“
Zahl „number“
String „string“
Hostobjekt (bereitgestellt durch die JS-Umgebung) Implementierungsabhängig
Funktionsobjekt (implementiert [[Call]] in ECMA-262-Begriffen) „function“
E4X XML-Objekt „xml“
E4X XMLList-Objekt „xml“
Jedes andere Objekt „Objekt“

// Zahlen

typeof 37 === 'number';
typeof 3.14 === 'number';
typeof Math.LN2 = == 'number';
typeof Infinity === 'number';
typeof NaN === 'number'; // Obwohl es sich um „Not-A-Number“ handelt
typeof Number(1) = == 'number'; // aber niemals diese Form verwenden!

// Strings

typeof "" === 'string';

typeof "bla" === 'string';
typeof (typeof 1) === 'string'; // typeof gibt immer einen String zurück
typeof String("abc") === 'string'; // aber verwende niemals diese Form!

// Booleans

typeof true === 'boolean';

typeof false === 'boolean';
typeof Boolean(true) === 'boolean'; // aber niemals verwenden dieses Formular!

// Undefiniert

typeof undefiniert === 'undefiniert';

typeof blabla === 'undefiniert'; // eine undefinierte Variable

// Objekte

typeof {a:1} === 'object';

typeof [1, 2, 4] === 'object'; // zur Unterscheidung Array.isArray oder Object.prototype.toString.call verwenden reguläre Objekte aus Arrays
typeof new Date() === 'object';

typeof new Boolean(true) === 'object'; // das ist verwirrend!

typeof new Number(1) === 'object'; // das ist verwirrend!

typeof new String("abc") === 'object'; // das ist verwirrend. Nicht verwenden!

// Funktionen

typeof function(){} === 'function';

typeof Math.sin === 'function';

typeof undefiniert;//"undefiniert"

typeof null;//"object" Dies steht seit Beginn von JavaScript
typeof /s/ === 'object'; // Konform mit ECMAScript 5.1typeof Beachten Sie, dass das Ergebnis des Umschließens eines Objekts „Objekt“ ist. Es gibt hier keine Bewertung, ob es gut oder schlecht ist (wenn Sie zwischen verpackten Objekten und primitiven Typen unterscheiden müssen). Typeof ist jedoch keine robuste Methode und sollte mit Vorsicht verwendet werden. Zum Beispiel:

var s = "I am a string";

typeof s === "string";
//Füge eine Methode zu String hinzu
String.prototype . A_String_Method = function(){
console.log(this.valueOf());
console.log(typeof this);
};
s.A_String_Method();
/ / Ich bin ein String
//Objekt