Dans es6, vous pouvez utiliser la méthode isArray() de Array pour déterminer si une variable est un tableau. Cette méthode est utilisée pour déterminer si un objet est de type tableau. La syntaxe est « Array.isArray(obj) » ; un tableau, il renvoie vrai, sinon il renvoie faux.
L'environnement d'exploitation de ce tutoriel : système Windows 7, ECMAScript version 6, ordinateur Dell G3.
Déterminer si une variable est un tableau dans ES5 Dans ES5
, nous avons au moins les 5 façons suivantes pour déterminer si une valeur est un tableau :
var a = []; // 1. Basé sur une instance de une instance de Array ; // 2. Basé sur le constructeur a.constructor === Tableau ; // 3. Basé sur Object.prototype.isPrototypeOf Array.prototype.isPrototypeOf(a); // 4. Basé sur getPrototypeOf Object.getPrototypeOf(a) === Array.prototype; // 5. Basé sur Object.prototype.toString Object.prototype.toString.apply(a) === '[object Array]';
Ci-dessus, à l'exception de Object.prototype.toString , les autres méthodes ne peuvent pas déterminer correctement le type de la variable.
Vous savez, l'environnement d'exécution du code est très complexe et une variable peut utiliser toutes sortes d'astuces pour confondre son créateur. Voyons
var a = {
__proto__ : Array.prototype
} ;
//Essayez d'exécuter respectivement les codes suivants dans la console // 1. Basé sur instanceof
une instance de Array ; // => vrai
// 2. Basé sur le constructeur
a.constructeur === Tableau ; // => vrai
// 3. Basé sur Object.prototype.isPrototypeOf
Array.prototype.isPrototypeOf(a); // => vrai
// 4. Basé sur getPrototypeOf
Object.getPrototypeOf(a) === Array.prototype; // => true ci-dessus, les quatre méthodes renverront true Pourquoi ? Nous venons de spécifier manuellement l'attribut __proto__ d'un objet comme Array.prototype, ce qui a fait hériter de l'objet Array. Cette méthode d'héritage irresponsable a provoqué l'effondrement instantané du système de jugement basé sur l'héritage.
Non seulement cela, nous savons également qu'Array est constitué de données de tas et que la variable pointe uniquement vers son adresse de référence, donc l'adresse référencée par l'objet Array de chaque page est différente. Pour un tableau déclaré dans une iframe, son constructeur est l'objet Array dans l'iframe. Si un tableau x est déclaré dans l'iframe et affecté à la variable y de la page parent, alors y instanceof Array est utilisée sur la page parent et le résultat doit être faux. Le dernier renvoie une chaîne, il n'y a donc pas de problème de référence. En fait, les interactions entre plusieurs pages ou systèmes ne sont possibles qu'avec des chaînes.
Déterminer si une variable est un tableau dans ES6
Compte tenu de l'utilisation courante des tableaux, la méthode Array.isArray est ajoutée dans ES6. L'utilisation de cette méthode pour déterminer si une variable est un tableau est très simple, comme suit :
Array.isArray. ([]); // => vrai
Array.isArray({0: 'a', length: 1}); // => false En fait, utiliser Object.prototype.toString pour déterminer le type d'une valeur est également un standard pour les principales bibliothèques grand public. Par conséquent, le polyfill pour Array.isArray ressemble généralement à ceci :
if (!Array.isArray){
Array.isArray = fonction (arg) {
return Object.prototype.toString.call(arg) === '[object Array]';
} ;
}