Comment vérifier si un objet est un tableau?

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, il suffit donc de les utiliser Array.isArray- ils sont désormais bien pris en charge et fonctionnent sur tous les cadres .

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érents cadres, vous pouvez également simplement utiliser instanceof

obj instanceof Array

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

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

Ou vous pouvez utiliser typeofpour 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 approfondi sur le blog de @TJ Crowder , comme indiqué dans son commentaire ci-dessous.

Consultez cette référence 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']

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' instanceofopérateur

v instanceof Array

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

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>

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

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

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

Array.isArray fonctionne rapidement, mais il n'est pas pris en charge par toutes les versions de 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]';
        }

Fonction simple pour vérifier cela:

function isArray(object)
{
    return object.constructor === Array;
}

Comme MDN le dit ici :

utilisez Array.isArray ou Object.prototype.toString.call pour différencier les objets réguliers des tableaux

Comme ça:

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

• Array.isArray(arr)

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.

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

var myArray=[];

if(myArray instanceof Array)
{
....
}

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
}

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)

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

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]";
};

J'ai mis à jour le violon jsperf 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).

Je sais que les gens recherchent une sorte d'approche javascript brute. Mais si vous voulez y penser 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

La meilleure solution que j'ai vue est un remplacement multi-navigateur pour typeof. Consultez 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 */};

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 la toStringméthode recommandée .

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

Il y a un bel exemple dans le livre JavaScript Patterns de Stoyan Stefanov qui suppose de gérer tous les problèmes possibles ainsi que d'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 ()

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

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");
}

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

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

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 typeofvérification de la possibilité de chaîne:

function someFunc(arg) {
    var arr = (typeof arg == "string") ? [arg] : arg;
}

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.

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

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é du blog de TJ Crowders

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

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

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

Je l'ai utilisé Array.isArrayici parce que c'est le plus robuste et aussi le plus simple.

Dans votre cas, vous pouvez utiliser la concatméthode 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 le sait bien).