1. typeof

Tout d'abord, nous penserions à utiliser typeof pour détecter le type de données, mais pour les types de base tels que Function, String, Number, Undefined, etc., typeof peut les détecter tous. Par exemple, le code est le suivant :

function test(){} console.log(typeof 1); // number console.log(typeof test); // function console.log(typeof "yunxi"); // string console.log(typeof undefined); // undefined

Mais pour les tableaux ou les expressions régulières, utiliser typeof pour les détecter ne suffira pas, car lorsque nous détectons un tableau ou une expression régulière, le type renvoyé sera un objet. Comme le montre le code suivant :

console.log(typeof []); // object console.log(typeof /\d+/g); // object

2. Instanceof

À partir de cela, on peut facilement penser à utiliser instanceof pour détecter si un objet est une instance d'un tableau. Cette détection renvoie un booléen. S'il s'agit d'un tableau, elle renvoie true ; sinon, elle renvoie false. Regardons le code ci-dessus pour détecter s'il s'agit d'un tableau :

console.log([] instanceof Array); // true console.log(/\d+/g instanceof Array); // false

Comme on peut le voir ci-dessus, l'utilisation de instanceof peut effectivement déterminer s'il s'agit d'un tableau.

3. Propriété constructor

En JavaScript, chaque objet possède une propriété constructor, qui référence la fonction constructeur qui a initialisé l'objet. Par exemple, pour déterminer le type d'un objet inconnu, on peut écrire une méthode comme suit :

function isArray(obj) { return typeof obj == 'object' && obj.constructor == Array } //Démo de test console.log(isArray([])); // true var a = {"a":1}; console.log(isArray(a)); // false var b = [1,2,3]; console.log(isArray(b)); // true console.log(isArray(/\d+/g));// false

Comme on peut le voir ci-dessus, en appelant la méthode isArray, nous pouvons également déterminer s'il s'agit d'un tableau.

Nous pouvons maintenant voir que pour les points 2 et 3, l'utilisation de la méthode instanceof et de la propriété constructor, respectivement, semble permettre de déterminer s'il s'agit d'un tableau. Cependant, il y a des exceptions. Par exemple, lorsqu'on utilise un tableau provenant d'une page à travers des frames (iframe), cela échouera, car dans différentes frames (iframes), les tableaux créés ne partagent pas leur propriété prototype entre eux. Le test de code suivant peut le vérifier~

var iframe = document.createElement('iframe'); document.body.appendChild(iframe); xArray = window.frames[window.frames.length-1].Array; var arr = new xArray("1","2","3","4","5"); //Cette syntaxe n'est pas prise en charge dans IE ; elle est disponible dans les navigateurs standard tels que Firefox et Chrome. console.log(arr); //Affiche ["1", "2", "3", "4", "5"] console.log(arr instanceof Array); // false console.log(arr.constructor === Array); // false

Aucune des méthodes ci-dessus ne permet de déterminer si un objet est un tableau ; toutefois, lorsque nous examinons ECMA262, nous pouvons voir que la méthode Object.prototype.toString.call() peut être utilisée pour déterminer si un objet est un tableau. Le code est le suivant :

function isArray(obj) { return Object.prototype.toString.call(obj) == '[object Array]'; } //Appel de code console.log(isArray([])); // true console.log(isArray([1,2,3])); // true var iframe = document.createElement('iframe'); document.body.appendChild(iframe); xArray = window.frames[window.frames.length-1].Array; var arr = new xArray("1","2","3","4","5"); console.log(arr); // ["1","2","3","4","5"] console.log(isArray(arr)); // true