Question Comment vérifiez-vous si une variable est un tableau en JavaScript? [dupliquer]


Cette question a déjà une réponse ici:

Je voudrais vérifier si une variable est un tableau ou une seule valeur en JavaScript.

J'ai trouvé une solution possible ...

if (variable.constructor == Array)...

Est-ce la meilleure façon de le faire?


1478
2018-04-20 09:02


origine


Réponses:


Il existe plusieurs façons de vérifier si une variable est un tableau ou non. La meilleure solution est celle que vous avez choisie.

variable.constructor === Array

C'est la méthode la plus rapide sur Chrome, et probablement sur tous les autres navigateurs. Tous les tableaux étant des objets, la vérification de la propriété constructeur est un processus rapide pour les moteurs JavaScript.

Si vous rencontrez des problèmes pour savoir si une propriété objets est un tableau, vous devez d'abord vérifier si la propriété est présente.

variable.prop && variable.prop.constructor === Array

D'autres façons sont:

variable instanceof Array

Cette méthode fonctionne à propos de 1/3 de la vitesse comme le premier exemple. Toujours assez solide, l'air plus propre, si vous êtes tout à propos de joli code et pas tellement sur la performance. Notez que la vérification des numéros ne fonctionne pas variable instanceof Number retourne toujours false. Mettre à jour: instanceof maintenant va 2/3 la vitesse!

Array.isArray(variable)

Ce dernier est, à mon avis, le plus laid, et c'est l'un des plus lents. Courir environ 1/5 de la vitesse comme le premier exemple. Array.prototype, est en fait un tableau. vous pouvez en lire plus à ce sujet ici https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray

Donc encore une autre mise à jour

Object.prototype.toString.call(variable) === '[object Array]';

Ce gars est le plus lent pour essayer de vérifier un tableau. Cependant, c'est un guichet unique pour tout type que vous recherchez. Cependant, puisque vous cherchez un tableau, utilisez simplement la méthode la plus rapide ci-dessus.

En outre, j'ai effectué un test: http://jsperf.com/instanceof-array-vs-array-isarray/33 Alors amusez-vous et vérifiez-le.

Note: @EscapeNetscape a créé un autre test car jsperf.com est en panne. http://jsben.ch/#/QgYAV Je voulais m'assurer que le lien original reste à chaque fois que jsperf revient en ligne.


1312
2017-10-29 15:07



Vous pouvez également utiliser:

if (value instanceof Array) {
  alert('value is Array!');
} else {
  alert('Not an array');
}

Cela me semble une solution assez élégante, mais à chacun le sien.

Modifier:

Depuis ES5, il y a maintenant:

Array.isArray(value);

Mais cela va casser sur les navigateurs plus anciens, sauf si vous utilisez des polyfills (essentiellement ... IE8 ou similaire).


982
2018-04-20 09:05



J'ai remarqué que quelqu'un a mentionné jQuery, mais je ne savais pas qu'il y avait un isArray() fonction. Il s'avère qu'il a été ajouté dans la version 1.3.

jQuery l'implémente comme Peter le suggère:

isArray: function( obj ) {
    return toString.call(obj) === "[object Array]";
},

Ayant déjà fait confiance à jQuery (en particulier leurs techniques de compatibilité entre navigateurs), je passerai à la version 1.3 et j'utiliserai leur fonction (à condition que la mise à niveau ne cause pas trop de problèmes) ou j'utiliserai directement cette méthode code.

Merci beaucoup pour les suggestions.


72
2018-04-20 10:10



Il existe plusieurs solutions avec toutes leurs propres bizarreries. Cette page donne un bon aperçu. Une solution possible est:

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

71
2018-04-20 09:08



Dans les navigateurs modernes (et certains navigateurs hérités), vous pouvez faire

Array.isArray(obj)

(Supporté par Chrome 5, Firefox 4.0, IE 9, Opera 10.5 et Safari 5)

Si vous avez besoin de supporter les anciennes versions d'IE, vous pouvez utiliser es5-shim pour polyfill Array.isArray; ou ajouter le suivant

# only implement if no native implementation is available
if (typeof Array.isArray === 'undefined') {
  Array.isArray = function(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  }
};

Si vous utilisez jQuery, vous pouvez utiliser jQuery.isArray(obj) ou $.isArray(obj). Si vous utilisez le soulignement, vous pouvez utiliser _.isArray(obj)

Si vous n'avez pas besoin de détecter des tableaux créés dans des cadres différents, vous pouvez également utiliser instanceof

obj instanceof Array

Remarque: la arguments Le mot-clé qui peut être utilisé pour accéder à l'argument d'une fonction n'est pas un tableau, même s'il se comporte (habituellement) comme un:

var func = function() {
  console.log(arguments)        // [1, 2, 3]
  console.log(arguments.length) // 3
  console.log(Array.isArray(arguments)) // false !!!
  console.log(arguments.slice)  // undefined (Array.prototype methods not available)
  console.log([3,4,5].slice)    // function slice() { [native code] } 
}
func(1, 2, 3)

54
2018-01-08 07:37



C'est une vieille question mais ayant le même problème j'ai trouvé une solution très élégante que je veux partager.

L'ajout d'un prototype à Array le rend très simple

Array.prototype.isArray = true;

Maintenant, une fois, si vous avez un objet que vous voulez tester pour voir si c'est un tableau, tout ce dont vous avez besoin est de vérifier la nouvelle propriété

var box = doSomething();

if (box.isArray) {
    // do something
}

isArray n'est disponible que si c'est un tableau


49
2017-10-24 21:12



Via Crockford:

function typeOf(value) {
    var s = typeof value;
    if (s === 'object') {
        if (value) {
            if (value instanceof Array) {
                s = 'array';
            }
        } else {
            s = 'null';
        }
    }
    return s;
}

Le principal échec de Crockford mentions est une incapacité à déterminer correctement les tableaux qui ont été créés dans un contexte différent, par exemple, window. Cette page a une version beaucoup plus sophistiquée si cela est insuffisant.


45
2018-04-20 09:07



Personnellement, j'aime la suggestion de Peter: https://stackoverflow.com/a/767499/414784 (pour ECMAScript 3. Pour ECMAScript 5, utilisez Array.isArray())

Les commentaires sur le poste indiquent cependant que si toString() est changé du tout, cette façon de vérifier un tableau échouera. Si vous voulez vraiment être précis et vous assurer toString() n'a pas été modifié et il n'y a aucun problème avec l'attribut de classe d'objets ([object Array] est l'attribut de classe d'un objet qui est un tableau), alors je recommande de faire quelque chose comme ceci:

//see if toString returns proper class attributes of objects that are arrays
//returns -1 if it fails test
//returns true if it passes test and it's an array
//returns false if it passes test and it's not an array
function is_array(o)
{
    // make sure an array has a class attribute of [object Array]
    var check_class = Object.prototype.toString.call([]);
    if(check_class === '[object Array]')
    {
        // test passed, now check
        return Object.prototype.toString.call(o) === '[object Array]';
    }
    else
    {
        // may want to change return value to something more desirable
        return -1; 
    }
}

Notez que dans JavaScript The Definitive Guide 6th edition, 7.10, il est dit Array.isArray() est mis en œuvre en utilisant Object.prototype.toString.call() dans ECMAScript 5. Notez également que si vous vous inquiétez de toString()L'implémentation change, vous devriez aussi vous inquiéter de la modification de toute autre méthode intégrée. Pourquoi utiliser push()? Quelqu'un peut le changer! Une telle approche est stupide. Le contrôle ci-dessus est une solution proposée à ceux qui s'inquiètent de toString() changer, mais je crois que le contrôle est inutile.


26
2017-12-03 03:17



Lorsque j'ai posté cette question, la version de JQuery que j'utilisais n'incluait pas isArray fonction. Si cela avait été le cas, je l'aurais probablement utilisé juste en faisant confiance à cette implémentation pour être la meilleure façon de faire ce type particulier de navigateur.

Puisque JQuery offre maintenant cette fonction, je l'utiliserais toujours ...

$.isArray(obj);

(à partir de la version 1.6.2) Il est toujours implémenté en utilisant des comparaisons sur les chaînes dans le formulaire

toString.call(obj) === "[object Array]"

19
2017-08-08 14:42