Comment vérifier si un objet est un tableau?
J'essaie d'écrire une fonction qui accepte une liste de chaînes ou une seule chaîne. Si c'est une chaîne, alors je veux le convertir en tableau avec seulement un élément. Ensuite, je peux le parcourir sans crainte d'erreur.
Alors, comment puis-je vérifier si la variable est un tableau?
J'ai arrondi les différentes solutions ci-dessous et créé un test jsperf .
Dans les navigateurs modernes, vous pouvez faire
Array.isArray(obj)
( Pris en charge par Chrome 5, Firefox 4.0, IE 9, Opera 10.5 et Safari 5)
Pour la compatibilité ascendante, vous pouvez ajouter ce qui suit
# 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 des cadres différents, vous pouvez simplement utiliser instanceof
obj instanceof Array
La méthode indiquée dans le standard ECMAScript pour trouver la classe d'Object consiste à utiliser la méthode toString à partir de Object.prototype.
if( Object.prototype.toString.call( someVar ) === '[object Array]' ) {
alert( 'Array!' );
}
Ou vous pouvez utiliser typeof pour vérifier 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 créer une concat dans 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 de @ T.J. Le blog de Crowder, comme indiqué dans son commentaire ci-dessous.
Consultez ce benchmark pour avoir une idée de la méthode la plus performante: http://jsben.ch/#/QgYAV
De @Bharath , convertissez une 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'opérateur instanceof
v instanceof Array
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>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 et anciens navigateurs):
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);
Underscore 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 créer 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 ceci:
function isArray(object)
{
if (object.constructor === Array) return true;
else return false;
}
Comme dit MDN ici :
utilisez Array.isArray ou Object.prototype.toString.call pour différencier objets réguliers de tableaux
Comme ça:
Object.prototype.toString.call(arr) === '[object Array]', ouArray.isArray(arr)
Il n'y a qu'une solution en une ligne pour cette question
x instanceof Array
où x est la variable, il retournera true si x est un tableau et false si ce n'est pas le cas.
Je créerais une fonction pour tester le type d'objet avec lequel 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 Stringalors vous pouvez écrire une simple déclaration if ...
if(whatAmI(myVar) === "Array"){
// do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
// do string stuff
}
Vous pouvez vérifier le type de votre variable pour savoir s'il s'agit d'un tableau avec;
var myArray=[];
if(myArray instanceof Array)
{
....
}
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)
Ceci 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 rend compte de 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 'Object' et 'Array' 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 indéfinie, mais elles fonctionnent si vous êtes certain qu'elles ont une valeur. Pour ce qui est de vérifier en fonction des performances si une valeur est un tableau ou une valeur unique, la seconde méthode ressemble à une méthode rapide valide. Il est légèrement plus rapide que 'instanceof' sur Chrome, deux fois plus vite que la deuxième meilleure méthode d'Internet Explorer, Opera et Safari (sur ma machine).
Je sais que les gens recherchent une sorte d’approche javascript brute . Mais si vous voulez moins réfléchir, jetez un oeil ici: http://underscorejs.org/#isArray
_.isArray(object)
Renvoie true 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 inter-navigateur pour typeof. Vérifiez la solution de 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 */};
Il existe un bel exemple dans le livre de Stoyan Stefanov JavaScript Patterns qui supposent gérer tous les problèmes possibles et utiliser la méthode ECMAScript 5 Array.isArray () .
Alors la voici:
if (typeof Array.isArray === "undefined") {
Array.isArray = function (arg) {
return Object.prototype.toString.call(arg) === "[object Array]";
};
}
À propos, si vous utilisez jQuery, vous pouvez utiliser sa méthode $ .isArray ()
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 "déconner" le prototype, mais il semble fonctionner beaucoup mieux que la méthode toString recommandée .
Note: Un inconvénient de cette approche est qu'elle ne fonctionnera pas à travers iframe frontières , mais pour mon cas d'utilisation ce n'est pas un problème.
Ce qui suit pourrait ê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");
}le 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
Une fonction simple permettant de vérifier 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 avec plusieurs navigateurs et avec les anciens navigateurs. Ceci est tiré de T.J. Blog de Crowders
Cette fonction transformera presque tout 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 certaines fonctionnalités plus récentes du navigateur, vous pouvez donc vouloir le polyfiller pour un support maximal.
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 case à cocher 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.
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
Dans votre cas, vous pouvez utiliser la méthode concat de Array qui peut accepter des objets simples aussi bien 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 méthodes les plus anciennes de Array (même IE 5.5 le sait bien).
Si les deux seules sortes de valeurs pouvant être transmises à cette fonction sont une chaîne ou un tableau de chaînes, restez simple et utilisez une vérification typeof pour 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 eu jusqu'à présent.
Notez qu'il n'y a pas de fonction parfaite qui détectera toujours toutes les combinaisons possibles. Il est préférable de 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))
Heureusement, ECMA 5 a introduit Array.isArray() en décembre 2009. Si, pour une raison quelconque, vous utilisez une version de JavaScript plus ancienne que ECMA 5, veuillez effectuer la mise à niveau.
Cependant, si vous insistez dessus, les tableaux ont certaines propriétés qui les différencient de tout autre type. Des propriétés que je n'ai pas vues mentionnées dans aucune des réponses. Entrons dans la politique JavaScript.
Un tableau est un objet (typeof [] === "object"), mais contrairement aux objets traditionnels, ils ont une propriété length (typeof ( {} ).length === "undefined"). null est aussi un objet (typeof null === "object"), mais vous ne pouvez pas accéder à une propriété de null car null est non un objet. Il s’agit d’un bogue de la spécification qui remonte au tout début de JavaScript, lorsque les objets avaient le type tag 0 et que null était représenté par un pointeur null littéral 0x00, ce qui avait amené l’interprète à le confondre avec les objets.
Malheureusement, cela ne représente pas [] vs {length:0}. Nous devons donc maintenant nous tourner vers la chaîne de prototypes.
( [] ).__proto__ === Array.prototype && ( [] ).__proto__ !== Object.prototype.
Ainsi, sans Array.isArray(), c’est à peu près ce que nous pouvons obtenir de plus près:
function is_array(array){
return array !== null
&& typeof array === "object"
&& array.__proto__ === Array.prototype;
}
[ [], [1,2,3], {length: 0}, {},
1, 0, Infinity, NaN, "1", "[1,2,3]",
null, undefined, [null], [undefined], {a:[]},
[{}], [{length: 0}], [Infinity], [NaN],
{__proto__: Array.prototype}
].filter(is_array)
// Expected: [ [], [1,2,3], [null], [undefined], [{}], [{length: 0}], [Infinity], [NaN] ]
// Actual: [ [], [1,2,3], [null], [undefined], [{}], [{length: 0}], [Infinity], [NaN], {__proto__: Array.prototype} ]
L'objet conçu de manière malicieuse pour ressembler à un tableau passe réellement le test de turing. Cependant, le remplacement de la chaîne de prototypes par la chaîne de prototypes Array est suffisant pour le faire agir comme un tableau, ce qui en fait un tableau. La seule chose au monde qui puisse dire qu'un tel objet n'est en réalité pas un tableau, c'est Array.isArray(). Mais pour les besoins que vous vérifieriez habituellement si un objet est un tableau, cet objet doit jouer à Nice avec votre code. Même le comportement lorsque vous modifiez artificiellement la longueur du tableau est identique: si sa longueur est supérieure au nombre d'éléments du tableau, vous aurez des "emplacements vides" de ce type spécial "implicite non défini" qui est en quelque sorte distinct de non défini tout en étant aussi === undefined; le même type que celui qui a motivé l'utilisation de typeof obj !== "undefined" pour éviter de lancer ReferenceError car obj === undefined uniquement n'a pas renvoie une erreur si obj a été explicitement défini comme undefined.
a = {__proto__: Array.prototype}; // Array {}
a.Push(5)
a // [5]
a.length = 5
a // [5, empty x 4]
b = a.map(n => n*n) // [25, empty x 4]
b.Push(undefined)
b.Push(undefined)
b // [25, empty x 4, undefined, undefined]
b[1] // undefined
b[1] === b[5] // true
Array.isArray(a) // false
Array.isArray(b) // true
N'utilisez pas is_array(), cependant. C'est une chose de réinventer la roue à des fins d'apprentissage. C'est une autre chose de le faire dans le code de production. Ne l'utilisez même pas comme un polyfill. La prise en charge des anciennes versions de JS signifie que la prise en charge des anciens navigateurs signifie que l'utilisation de logiciels non sécurisés signifie que l'utilisateur est exposé aux logiciels malveillants.
D'autres méthodes existent également pour vérifier, mais je préfère la méthode suivante Comme meilleur moyen de vérifier (car vous pouvez facilement vérifier les types d'autres objets).
> a = [1, 2]
[ 1, 2 ]
>
> Object.prototype.toString.call(a).slice(8,).replace(/\]$/, '')
'Array'
>
> Object.prototype.toString.call([]).slice(8,-1) // best approach
'Array'
Explication (avec des exemples simples sur le nœud REPL) »
> o = {'ok': 1}
{ ok: 1 }
> a = [1, 2]
[ 1, 2 ]
> typeof o
'object'
> typeof a
'object'
>
> Object.prototype.toString.call(o)
'[object Object]'
> Object.prototype.toString.call(a)
'[object Array]'
>
Objet ou tableau »
> Object.prototype.toString.call(o).slice(8,).replace(/\]$/, '')
'Object'
>
> Object.prototype.toString.call(a).slice(8,).replace(/\]$/, '')
'Array'
>
Null ou Undefined »
> Object.prototype.toString.call(undefined).slice(8,).replace(/\]$/, '')
'Undefined'
> Object.prototype.toString.call(null).slice(8,).replace(/\]$/, '')
'Null'
>
Chaîne "
> Object.prototype.toString.call('ok').slice(8,).replace(/\]$/, '')
'String'
Nombre "
> Object.prototype.toString.call(19).slice(8,).replace(/\]$/, '')
'Number'
> Object.prototype.toString.call(19.0).slice(8,).replace(/\]$/, '')
'Number'
> Object.prototype.toString.call(19.7).slice(8,).replace(/\]$/, '')
'Number'
>
J'apprécie la suggestion de @mpen d'utiliser -1 à la place de l'expression régulière comme suit.
> Object.prototype.toString.call(12).slice(8,-1)
'Number'
>
> Object.prototype.toString.call(12.0).slice(8,-1)
'Number'
>
> Object.prototype.toString.call([]).slice(8,-1)
'Array'
> Object.prototype.toString.call({}).slice(8,-1)
'Object'
>
> Object.prototype.toString.call('').slice(8,-1)
'String'
>
var is_array = function (value) {
return value &&
typeof value === 'object' &&
typeof value.length === 'number' &&
typeof value.splice === 'function' &&
!(value.propertyIsEnumerable('length'));
};
Cette fonction est extraite du livre "JS the good parts" et fonctionne parfaitement pour moi.
Vous pouvez également vérifier avec la propriété length de array. Lorsque vous essayez d'accéder à la propriété de longueur d'un tableau, il renvoie un nombre (0 pour un tableau vide), tandis que si vous tentez d'accéder à la propriété de longueur d'un objet, il renvoie non défini.
if(Object.prototype.toString.call(arrayList) === '[object Array]') {
console.log('Array!');
}
Je sais que c'est une vieille question, mais j'ai trouvé la réponse la plus courte maintenant:
var x = [1,2,3]
console.log(x.map?1:0)Je sais que c’est une vieille question mais voici une solution que j’ai imaginée et que j’utilise depuis longtemps pour mes projets ...
function isArray (o) {
return typeof o === "object" && o.length !== undefined;
}
isArray({}); // false
isArray(1); // false
isArray("str"); // false
isArray(function(){}); // false
isArray([]); // true
Le seul piège est qu'il donnera un faux positif s'il se trouve que votre objet a une propriété length:
isArray({length:0}); // true
Si cet inconvénient vous convient et que vous savez que vos objets purs n'auront pas cette propriété, il s'agit d'une solution propre qui devrait être plus rapide que la méthode Object.prototype.toString.call.
vous pouvez d’abord vérifier console.log (typeof Object)
si la sortie est objet, alors var {data} = objet, c’est-à-dire qu’il suffit de déstructurer l’objet en fonction des clés d’objet. et la fonction peut être comme ça.
const abc=(str1,str2=null)=>{
var result=[];
result.Push(str1);result.Push(str2);
return result.join("");
}
il y a une différence entre checkout its prototype et Array.isArray:
function isArray(obj){
return Object.getPrototypeOf(obj) === Array.prototype
}
cette fonction vérifiera directement si un obj est un tableau
mais pour cet objet proxy:
var arr = [1,2,3]
var proxy = new Proxy(arr,{})
console.log(Array.isArray(proxy)) // true
Array.isArray le prendra comme tableau.
La meilleure pratique consiste à comparer avec constructor, quelque chose comme ceci.
if(some_variable.constructor === Array){
// do something
}
Vous pouvez également utiliser d'autres méthodes, telles que typeOf, en les convertissant en chaîne, puis en les comparant, mais en les comparant à dataType est toujours une meilleure approche.
Vous pouvez utiliser cette fonction pour obtenir le type de données.
var myAr = [1,2];
checkType(myAr);
function checkType(data){
if(typeof data ==='object'){
if(Object.prototype.toString.call(data).indexOf('Array')!==(-1)){
return 'array';
} else{
return 'object';
}
} else {
return typeof data;
}
}
if(checkType(myAr) === 'array'){console.log('yes, It is an array')};
Comme je n’aime pas les appels Object.prototype-, j’ai cherché une autre solution. Surtout parce que les solutions de ChaosPandion ne fonctionnent pas toujours et que la solution MidnightTortoise avec isArray() ne fonctionne pas avec les tableaux provenant du DOM (comme getElementsByTagName ). Et finalement, j'ai trouvé une solution simple et multi-navigateurs, qui aurait probablement aussi fonctionné avec Netscape 4.;)
C'est juste ces 4 lignes (vérifiant n'importe quel objet h):
function isArray(h){
if((h.length!=undefined&&h[0]!=undefined)||(h.length===0&&h[0]===undefined)){
return true;
}
else{ return false; }
}
J'ai déjà testé ces tableaux (tous retournent vrais):
1) array=d.getElementsByName('some_element'); //'some_element' can be a real or unreal element
2) array=[];
3) array=[10];
4) array=new Array();
5) array=new Array();
array.Push("whatever");
Quelqu'un peut-il confirmer que cela fonctionne dans tous les cas? Ou quelqu'un trouve-t-il un cas où ma solution ne fonctionne pas?
Voici un extrait de code qui expliquera un fait important sur les tableaux qui devraient être connus dès l’apprentissage de JS (contrairement à moi).
// this functions puts a string inside an array
var stringInsideArray = function(input) {
if (typeof input === 'string') {
return [input];
}
else if (Array.isArray(input)) {
return input;
}
else {
throw new Error("Input is not a string!");
}
}
var output = stringInsideArray('hello');
console.log('step one output: ', output); // ["hello"]
// use typeof method to verify output is an object
console.log('step two output: ', typeof output); // object
// use Array.isArray() method to verify output is an array
console.log('step three output: ', Array.isArray(output)); // trueLes tableaux , sont en fait des objets.
En utilisant l'opérateur typeof , la sortie de stringInsideArray('hello') prouve que ["hello"] est vraiment un objet. Cela m'a laissé perplexe pendant très longtemps parce que je supposais que les tableaux seraient un type de données JavaScript ...
Il n'y a que 7 types de données JS et les tableaux sont ET NON l'un d'entre eux.
Pour répondre à votre question, utiliser la méthode Array.isArray () détermine que la variable output est un tableau.
Array.isArray est le moyen d'y parvenir. Par exemple:
var arr = ['tuna', 'chicken', 'pb&j'];
var obj = {sandwich: 'tuna', chips: 'cape cod'};
// Returns true
Array.isArray(arr);
// Return false
Array.isArray(obj);
Vous pouvez trouver avec Push comme ci-dessous:
function isArray(obj){
return (typeof obj.Push=== 'function')?true:false;
}
var array=new Array();
or
var array=['a','b','c'];
console.log(isArray(array));