Résumé de la façon dont JavaScript utilise les opérateurs et les propriétés pour déterminer le type d'objet

Les opérateurs permettant de détecter les types d'objets en JavaScript incluent : typeof, instanceof et l'attribut constructeur de l'objet :

1) l'opérateur typeof typeof est un opérateur unaire, Le résultat renvoyé est une chaîne décrivant le type d'opérande. Par exemple : "numéro", "chaîne", "booléen", "objet", "fonction", "undéfini" (peut être utilisé pour déterminer si une variable existe). Cependant, typeof a des capacités limitées. Il renvoie « objet » pour les types Date et RegExp. Tels que :

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

Il n'est donc utile que pour distinguer les objets et les types primitifs. Pour distinguer un type d'objet d'un autre, d'autres méthodes doivent être utilisées. Tels que : opérateur instanceof ou attribut constructeur de l'objet.

2) instance d'opérateur. L'opérateur instanceof nécessite que l'opérande de gauche soit un objet et que l'opérande de droite soit le nom ou le constructeur de la classe d'objet. L'opérateur instanceof renvoie true si l'objet est une instance d'une classe ou d'un constructeur. Renvoie false si l'objet n'est pas une instance de la classe ou de la fonction spécifiée, ou si l'objet est nul. Par exemple :

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

Par conséquent, vous pouvez utiliser l'opérateur instanceof pour déterminer si l'objet est de type tableau :

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

3) attribut constructeur. En JavaScript, chaque objet possède un attribut constructeur, qui fait référence au constructeur qui initialise l'objet. Il est souvent utilisé pour déterminer le type d'objets inconnus. Par exemple, étant donné une valeur à déterminer, utilisez l'opérateur typeof pour déterminer s'il s'agit d'une valeur primitive ou d'un objet. S'il s'agit d'un objet, vous pouvez utiliser l'attribut constructeur pour déterminer son type. Ainsi, la fonction pour déterminer le tableau peut également être écrite comme ceci :

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

Dans de nombreux cas, nous pouvons utiliser l'opérateur instanceof ou la propriété constructor de l'objet pour détecter si l'objet est un tableau. Par exemple, de nombreux frameworks JavaScript utilisent ces deux méthodes pour déterminer si un objet est de type tableau. Mais lors de la détection de tableaux dans des pages multi-images, cela échoue. La raison en est que les tableaux créés dans différentes images (iframes) ne partagent pas leurs propriétés de prototype entre eux. Par exemple :

<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>

J'ai vu une méthode de détection précise sur Ajaxian, appelant la méthode toString() à travers la chaîne de prototypes : Object.prototype.toString( ). Peut résoudre le problème inter-framework ci-dessus. Lorsque Object.prototype.toString(o) est exécuté, les étapes suivantes seront effectuées : 1) Obtenir l'attribut de classe de l'objet o. 2) Chaîne de connexion : "[object "+result(1)+"]" 3) Return result(2) Par exemple :

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

De cette façon, nous pouvons écrire une méthode robuste pour déterminer si l'objet est des fonctions Array :

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

Cette méthode a été reconnue par de nombreux maîtres JavaScript étrangers et sera utilisée dans le prochain tableau jQuery Check 1.3. Un responsable de prototype.js a écrit la fonction suivante, qui est utilisée pour obtenir le nom de type d'un objet

/**
 * 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];
};

Extended pour détecter divers objets Type :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!