J'essaie d'écrire une fonction qui accepte soit une liste de chaînes, soit une seule chaîne. Si c'est une chaîne, je veux la convertir en un tableau avec un seul élément, donc je peux la parcourir sans craindre une erreur.

Alors, comment puis-je vérifier si la variable est un tableau?


J'ai rassemblé les différentes solutions ci-dessous et créé un test jsperf. Ils sont tous rapides, alors utilisez simplement Array.isArray - c'est bien pris en charge maintenant et fonctionne sur plusieurs cadres.

2958
mpen 23 janv. 2011 à 21:53

30 réponses

Meilleure réponse

Dans les navigateurs modernes, vous pouvez le faire

Array.isArray(obj)

(Pris en charge par Chrome 5, Firefox 4.0, IE 9, Opera 10.5 et Safari 5)

Pour des raisons de compatibilité descendante, vous pouvez ajouter les éléments suivants

# 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 un trait de soulignement, vous pouvez utiliser _.isArray(obj)

Si vous n'avez pas besoin de détecter les tableaux créés dans différentes images, vous pouvez également simplement utiliser instanceof

obj instanceof Array
921
Fela Winkelmolen 20 nov. 2014 à 21:16

La méthode donnée dans la norme ECMAScript pour trouver la classe d'Object est d'utiliser la méthode toString de Object.prototype.

if( Object.prototype.toString.call( someVar ) === '[object Array]' ) {
    alert( 'Array!' );
}

Ou vous pouvez utiliser typeof pour tester s'il s'agit d'une chaîne:

if( typeof someVar === 'string' ) {
    someVar = [ someVar ];
}

Ou si vous n'êtes pas préoccupé par les performances, vous pouvez simplement faire un concat à un nouveau tableau vide.

someVar = [].concat( someVar );

Il y a aussi le constructeur que vous pouvez interroger directement:

if (somevar.constructor.name == "Array") {
    // do something
}

Découvrez un traitement complet à partir de @TJ Le blog de Crowder , comme indiqué dans son commentaire ci-dessous.

Consultez ce benchmark pour avoir une idée de la méthode qui fonctionne le mieux: http://jsben.ch/#/QgYAV

De @Bharath, convertissez la chaîne en tableau en utilisant Es6 pour la question posée:

const convertStringToArray = (object) => {
   return (typeof object === 'string') ? Array(object) : object 
}

Supposer:

let m = 'bla'
let n = ['bla','Meow']
let y = convertStringToArray(m)
let z = convertStringToArray(n)
console.log('check y: '+JSON.stringify(y)) . // check y: ['bla']
console.log('check y: '+JSON.stringify(z)) . // check y: ['bla','Meow']
1938
Robert Harvey 28 févr. 2018 à 23:30

Je voudrais d'abord vérifier si votre implémentation prend en charge isArray:

if (Array.isArray)
    return Array.isArray(v);

Vous pouvez également essayer d'utiliser l'opérateur instanceof

v instanceof Array
1267
ChaosPandion 23 janv. 2011 à 18:55

JQuery propose également une méthode $.isArray():

var a = ["A", "AA", "AAA"];

if($.isArray(a)) {
  alert("a is an array!");
} else {
  alert("a is not an array!");
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
298
Al Foиce ѫ 17 août 2016 à 07:41

C'est la plus rapide de toutes les méthodes (tous les navigateurs pris en charge):

function isArray(obj){
    return !!obj && obj.constructor === Array;
}
104
shinobi 19 févr. 2017 à 08:37

Imaginez que vous avez ce tableau ci-dessous :

var arr = [1,2,3,4,5];

Javascript (nouveaux navigateurs et anciens):

function isArray(arr) {
  return arr.constructor.toString().indexOf("Array") > -1;
}

Ou

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

Ou

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

Puis appelez-le comme ceci:

isArray(arr);

Javascript (IE9 +, Ch5 +, FF4 +, Saf5 +, Opera10.5 +)

Array.isArray(arr);

JQuery:

$.isArray(arr);

Angulaire:

angular.isArray(arr);

Souligner et Lodash:

_.isArray(arr);
47
Alireza 21 août 2019 à 07:10

Array.isArray fonctionne rapidement, mais il n'est pas pris en charge par toutes les versions des navigateurs. Vous pouvez donc faire une exception pour les autres et utiliser la méthode universelle:

    Utils = {};    
    Utils.isArray = ('isArray' in Array) ? 
        Array.isArray : 
        function (value) {
            return Object.prototype.toString.call(value) === '[object Array]';
        }
34
CruorVult 18 févr. 2013 à 11:18

Fonction simple pour vérifier cela:

function isArray(object)
{
    return object.constructor === Array;
}
24
Remolten 27 janv. 2020 à 19:40

Comme MDN le dit ici:

utilisez Array.isArray ou Object.prototype.toString.call pour différencier objets réguliers à partir de tableaux

Comme ça:

  • Object.prototype.toString.call(arr) === '[object Array]', ou

  • Array.isArray(arr)

17
ajax333221 14 sept. 2012 à 21:02

Il n'y a qu'une solution de ligne pour cette question

x instanceof Array

Où x est la variable, il retournera vrai si x est un tableau et faux s'il ne l'est pas.

17
Vikash Kumar 8 juin 2017 à 12:48

Vous pouvez vérifier le type de votre variable s'il s'agit d'un tableau avec;

var myArray=[];

if(myArray instanceof Array)
{
....
}
15
Ahmet DAL 15 janv. 2013 à 08:58

Je ferais une fonction pour tester le type d'objet que vous traitez ...

function whatAmI(me){ return Object.prototype.toString.call(me).split(/\W/)[2]; }

// tests
console.log(
  whatAmI(["aiming","@"]),
  whatAmI({living:4,breathing:4}),
  whatAmI(function(ing){ return ing+" to the global window" }),
  whatAmI("going to do with you?")
);

// output: Array Object Function String

Alors vous pouvez écrire une simple instruction if ...

if(whatAmI(myVar) === "Array"){
    // do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
    // do string stuff
}
15
Al Foиce ѫ 17 août 2016 à 07:46

Je le fais d'une manière très simple. Travaille pour moi. Des inconvénients?

Array.prototype.isArray = true;

a=[]; b={};
a.isArray  // true
b.isArray  // (undefined -> false)
12
rsbkk 4 avril 2015 à 06:58

C'est ma tentative d'améliorer cette réponse en tenant compte des commentaires:

var isArray = myArray && myArray.constructor === Array;

Il supprime le if / else et explique la possibilité que le tableau soit nul ou non défini

12
Community 23 mai 2017 à 12:34

https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/isArray

Array.isArray = Array.isArray || function (vArg) {
    return Object.prototype.toString.call(vArg) === "[object Array]";
};
11
yckart 1 avril 2013 à 05:32

J'ai mis à jour le jsperf fiddle avec deux méthodes alternatives ainsi que la vérification des erreurs.

Il s'avère que la méthode définissant une valeur constante dans les prototypes «Objet» et «Tableau» est plus rapide que toutes les autres méthodes. C'est un résultat quelque peu surprenant.

/* Initialisation */
Object.prototype.isArray = function() {
  return false;
};
Array.prototype.isArray = function() {
  return true;
};
Object.prototype._isArray = false;
Array.prototype._isArray = true;

var arr = ["1", "2"];
var noarr = "1";

/* Method 1 (function) */
if (arr.isArray()) document.write("arr is an array according to function<br/>");
if (!noarr.isArray()) document.write("noarr is not an array according to function<br/>");
/* Method 2 (value) - **** FASTEST ***** */
if (arr._isArray) document.write("arr is an array according to member value<br/>");
if (!noarr._isArray) document.write("noarr is not an array according to member value<br/>");

Ces deux méthodes ne fonctionnent pas si la variable prend la valeur non définie, mais elles fonctionnent si vous êtes certain qu'elles ont une valeur. En ce qui concerne la vérification en tenant compte des performances si une valeur est un tableau ou une valeur unique, la deuxième méthode ressemble à une méthode rapide valide. Il est légèrement plus rapide que «instanceof» sur Chrome, deux fois plus rapide que la deuxième meilleure méthode dans Internet Explorer, Opera et Safari (sur ma machine).

11
le_top 1 août 2015 à 11:10

Je sais que les gens recherchent une sorte d'approche javascript brute. Mais si vous voulez y réfléchir moins, jetez un œil ici: http://underscorejs.org/#isArray

_.isArray(object) 

Renvoie vrai si l'objet est un tableau.

(function(){ return _.isArray(arguments); })();
=> false
_.isArray([1,2,3]);
=> true
9
Sridhar 28 sept. 2015 à 13:27

La meilleure solution que j'ai vue est un remplacement multi-navigateur pour typeof. Vérifiez la solution d'Angus Croll ici.

La version TL; DR est ci-dessous, mais l'article est une excellente discussion sur le problème, vous devriez donc le lire si vous en avez le temps.

Object.toType = function(obj) {
    return ({}).toString.call(obj).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();
}
// ... and usage:
Object.toType([1,2,3]); //"array" (all browsers)

// or to test...
var shouldBeAnArray = [1,2,3];
if(Object.toType(shouldBeAnArray) === 'array'){/* do stuff */};
5
John Wundes 23 mars 2012 à 17:16

Voici mon approche paresseuse:

if (Array.prototype.array_ === undefined) {
  Array.prototype.array_ = true;
}

// ...

var test = [],
    wat = {};

console.log(test.array_ === true); // true
console.log(wat.array_ === true);  // false

Je sais que c'est un sacrilège de "jouer avec" le prototype, mais il semble fonctionner beaucoup mieux que le toString recommandé méthode.

Remarque: Un écueil de cette approche est qu'elle ne fonctionnera pas au-delà des iframe limites, mais pour mon cas d'utilisation, ce n'est pas un problème.

5
namuol 6 déc. 2013 à 02:07

Il y a un bel exemple dans le livre de Stoyan Stefanov Patterns JavaScript qui suppose de gérer tous problèmes possibles et utiliser la méthode ECMAScript 5 Array .isArray ().

Voici donc:

if (typeof Array.isArray === "undefined") {
    Array.isArray = function (arg) {
        return Object.prototype.toString.call(arg) === "[object Array]";
    };
}

Par ailleurs, si vous utilisez jQuery, vous pouvez utiliser sa méthode $ .isArray ()

5
Salvador Dali 16 déc. 2013 à 22:27

Moyen le plus simple et le plus rapide de vérifier si un objet est un tableau ou non.

 var arr = [];
  arr.constructor.name ==='Array'  //return true;

Ou

arr.constructor ===Array //return true;

Ou vous pouvez créer une fonction utilitaire:

function isArray(obj){ return obj && obj.constructor ===Array}

Usage:

isArray(arr); //return true
5
sheelpriy 29 mars 2017 à 06:25

Ce qui suit peut être utilisé si vous savez que votre objet n'a pas de méthode concat.

var arr = [];
if (typeof arr.concat === 'function') {
    console.log("It's an array");
}
5
Jan Aagaard 26 avril 2017 à 07:00

Vous pourriez est la méthode isArray mais je préférerais vérifier avec

Object.getPrototypeOf(yourvariable) === Array.prototype

5
STEEL 28 févr. 2018 à 17:21

Si les deux seuls types de valeurs pouvant être passés à cette fonction sont une chaîne ou un tableau de chaînes, restez simple et utilisez une typeof vérification de la possibilité de chaîne:

function someFunc(arg) {
    var arr = (typeof arg == "string") ? [arg] : arg;
}
4
Tim Down 23 janv. 2011 à 19:51
A = [1,2,3]
console.log(A.map==[].map)

À la recherche de la version la plus courte, voici ce que j'ai obtenu jusqu'à présent.

Notez qu'il n'y a pas de fonction parfaite qui détectera toujours toutes les combinaisons possibles. Il vaut mieux connaître toutes les capacités et les limites de vos outils que d’attendre un outil magique.

4
exebook 12 mars 2013 à 02:57
function isArray(value) {
    if (value) {
        if (typeof value === 'object') {
            return (Object.prototype.toString.call(value) == '[object Array]')
        }
    }
    return false;
}

var ar = ["ff","tt"]
alert(isArray(ar))
4
RoboTamer 30 oct. 2013 à 09:56

Une fonction simple pour tester si une valeur d'entrée est un tableau est la suivante:

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

Cela fonctionne sur plusieurs navigateurs et avec des navigateurs plus anciens. Ceci est tiré de T.J. Article de blog des Crowders

4
Brad Parks 2 févr. 2014 à 00:29

Vous pouvez essayer ceci:

var arr = []; (or) arr = new Array();
var obj = {}; (or) arr = new Object();

arr.constructor.prototype.hasOwnProperty('push') //true

obj.constructor.prototype.hasOwnProperty('push') // false
4
Michał Perłakowski 25 févr. 2016 à 15:54

Cette fonction transformera presque n'importe quoi en tableau:

function arr(x) {
    if(x === null || x === undefined) {
        return [];
    }
    if(Array.isArray(x)) {
        return x;
    }
    if(isString(x) || isNumber(x)) {
        return [x];
    }
    if(x[Symbol.iterator] !== undefined || x.length !== undefined) {
        return Array.from(x);
    }
    return [x];
}

function isString(x) {
    return Object.prototype.toString.call(x) === "[object String]"
}

function isNumber(x) {
    return Object.prototype.toString.call(x) === "[object Number]"
}

Il utilise des fonctionnalités de navigateur plus récentes, vous voudrez donc peut-être les remplir pour une prise en charge maximale.

Exemples:

> arr(null);
[]
> arr(undefined)
[]
> arr(3.14)
[ 3.14 ]
> arr(1/0)
[ Infinity ]
> gen = function*() { yield 1; yield 2; yield 3; }
[Function: gen]
> arr(gen())
[ 1, 2, 3 ]
> arr([4,5,6])
[ 4, 5, 6 ]
> arr("foo")
[ 'foo' ]

N.B. les chaînes seront converties en un tableau avec un seul élément au lieu d'un tableau de caractères. Supprimez la coche isString si vous préférez l'inverse.

J'ai utilisé Array.isArray ici parce que c'est le le plus robuste et aussi le plus simple.

4
mpen 24 oct. 2016 à 16:01

Dans votre cas, vous pouvez utiliser la méthode concat de Array qui peut accepter des objets uniques ainsi que des tableaux (et même combinés):

function myFunc(stringOrArray)
{
  var arr = [].concat(stringOrArray);

  console.log(arr);

  arr.forEach(function(item, i)
  {
    console.log(i, "=", item);
  })
}

myFunc("one string");

myFunc(["one string", "second", "third"]);

concat semble être l'une des plus anciennes méthodes d'Array (même IE 5.5 la connaît bien).

4
kolyaseg 15 sept. 2017 à 09:41