Zusammenfassung, wie JavaScript Operatoren und Eigenschaften verwendet, um den Objekttyp zu bestimmen

Zu den Operatoren zum Erkennen von Objekttypen in JavaScript gehören: typeof, instanceof und das Konstruktorattribut des Objekts:

1) typeof-Operator typeof ist ein unärer Operator, Das Rückgabeergebnis ist eine Zeichenfolge, die den Operandentyp beschreibt. Zum Beispiel: „Zahl“, „Zeichenfolge“, „boolescher Wert“, „Objekt“, „Funktion“, „undefiniert“ (kann verwendet werden, um festzustellen, ob eine Variable vorhanden ist). Allerdings verfügt typeof über begrenzte Funktionen. Es gibt „Objekt“ für die Typen „Date“ und „RegExp“ zurück. Zum Beispiel:

typeof {}; // "object" 
typeof []; // "object" 
typeof new Date(); // "object"

Es ist also nur nützlich, wenn Objekte und primitive Typen unterschieden werden sollen. Um einen Objekttyp von einem anderen zu unterscheiden, müssen andere Methoden verwendet werden. Zum Beispiel: Instanz des Operators oder Konstruktorattribut des Objekts.

2) Instanz des Operators. Der Instanzoperator erfordert, dass der Operand auf der linken Seite ein Objekt und der Operand auf der rechten Seite der Name der Objektklasse oder des Konstruktors ist. Der Instanzoperator gibt true zurück, wenn das Objekt eine Instanz einer Klasse oder eines Konstruktors ist. Gibt „false“ zurück, wenn das Objekt keine Instanz der angegebenen Klasse oder Funktion ist oder wenn das Objekt null ist. Beispiel:

[] instanceof Array; // true 
[] instanceof Object; // true 
[] instanceof RegExp; // false 
new Date instanceof Date; // true

Daher können Sie den Instanzoperator verwenden, um zu bestimmen, ob das Objekt ein Array-Typ ist:

function isArray(arr){ 
  return arr instanceof Array; 
}

3) Konstruktorattribut. In JavaScript verfügt jedes Objekt über ein Konstruktorattribut, das sich auf den Konstruktor bezieht, der das Objekt initialisiert. Es wird häufig verwendet, um den Typ unbekannter Objekte zu bestimmen. Wenn beispielsweise ein zu bestimmender Wert angegeben ist, können Sie mithilfe des Operators „typeof“ bestimmen, ob es sich um einen primitiven Wert oder ein Objekt handelt. Wenn es sich um ein Objekt handelt, können Sie dessen Typ mithilfe des Konstruktorattributs bestimmen. Die Funktion zur Bestimmung des Arrays kann also auch so geschrieben werden:

function isArray(arr){ 
  return typeof arr == "object" && arr.constructor == Array; 
}

In vielen Fällen können wir dazu den Instanzoperator oder die Konstruktoreigenschaft des Objekts verwenden Erkennen Sie, ob das Objekt ein Array ist. Beispielsweise verwenden viele JavaScript-Frameworks diese beiden Methoden, um zu bestimmen, ob ein Objekt ein Array-Typ ist. Beim Erkennen von Arrays in Cross-Frame-Seiten schlägt dies jedoch fehl. Der Grund dafür ist, dass Arrays, die in verschiedenen Frames (Iframes) erstellt wurden, ihre Prototypeigenschaften nicht miteinander teilen. Zum Beispiel:

<script>
window.onload=function(){
var iframe_arr=new window.frames[0].Array;
alert(iframe_arr instanceof Array); // false
alert(iframe_arr.constructor == Array); // false
}
</script>

Ich habe eine genaue Erkennungsmethode auf Ajaxian gesehen, die die toString()-Methode in der gesamten Prototypenkette aufruft: Object.prototype.toString( ). Kann das oben genannte Cross-Framework-Problem lösen. Wenn Object.prototype.toString(o) ausgeführt wird, werden die folgenden Schritte ausgeführt: 1) Rufen Sie das Klassenattribut von Objekt o ab. 2) Verbindungszeichenfolge: „[object „+result(1)+“]“ 3) Return result(2) Zum Beispiel:

Object.prototype.toString.call([] // Return „ [object Array]"
Object.prototype.toString.call(/reg/ig); // Return "[object RegExp]"

Auf diese Weise können wir eine robuste Methode schreiben, um zu bestimmen, ob Das Objekt ist Array-Funktionen:

function isArray(arr){
  return Object.prototype.toString.call(arr) === "[object Array]";
}

Diese Methode wurde von vielen ausländischen JavaScript-Mastern erkannt und wird im kommenden jQuery 1.3-Check-Array verwendet. Ein Betreuer von „prototyp.js“ hat die folgende Funktion geschrieben, die verwendet wird, um den Typnamen eines Objekts zu erhalten

/**
 * Returns internal [[Class]] property of an object
 *
 * Ecma-262, 15.2.4.2
 * Object.prototype.toString( )
 *
 * When the toString method is called, the following steps are taken: 
 * 1. Get the [[Class]] property of this object. 
 * 2. Compute a string value by concatenating the three strings "[object ", Result (1), and "]". 
 * 3. Return Result (2).
 *
 * __getClass(5); // => "Number"
 * __getClass({}); // => "Object"
 * __getClass(/foo/); // => "RegExp"
 * __getClass(''); // => "String"
 * __getClass(true); // => "Boolean"
 * __getClass([]); // => "Array"
 * __getClass(undefined); // => "Window"
 * __getClass(Element); // => "Constructor"
 *
 */
function __getClass(object){
  return Object.prototype.toString.call(object).match(/^\[object\s(.*)\]$/)[1];
};

Erweitert, um verschiedene Objekttypen zu erkennen:

var is ={
  types : ["Array", "Boolean", "Date", "Number", "Object", "RegExp", "String", "Window", "HTMLDocument"]
};
for(var i = 0, c; c = is.types[i ++ ]; ){
  is[c] = (function(type){
    return function(obj){
      return Object.prototype.toString.call(obj) == "[object " + type + "]";
    }
  )(c);
}
alert(is.Array([])); // true
alert(is.Date(new Date)); // true
alert(is.RegExp(/reg/ig)); // true

Das obige ist der detaillierte Inhalt vonZusammenfassung, wie JavaScript Operatoren und Eigenschaften verwendet, um den Objekttyp zu bestimmen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!