javascript array de - Comprobar si el objeto es una matriz?





15 Answers

El método dado en el estándar ECMAScript para encontrar la clase de Objeto es usar el método toString de Object.prototype .

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

O puedes usar typeof para probar si es una cadena:

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

O si no estás preocupado por el rendimiento, puedes hacer un acuerdo con una nueva matriz vacía.

someVar = [].concat( someVar );

También está el constructor que puede consultar directamente:

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

Echa un vistazo a un tratamiento completo del blog de @TJ Crowder , como se publicó en su comentario a continuación.

Echa un vistazo a este jsben.ch/#/QgYAV de jsben.ch/#/QgYAV para obtener una idea de qué método funciona mejor: jsben.ch/#/QgYAV

Desde @Bharath convierte una cadena a una matriz usando Es6 para la pregunta:

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

suponer:

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']
objetos recorrer buscar

Estoy tratando de escribir una función que acepte una lista de cadenas o una sola cadena. Si es una cadena, entonces quiero convertirla en una matriz con solo un elemento. Entonces puedo pasarlo por alto sin temor a un error.

Entonces, ¿cómo verifico si la variable es una matriz?

He redondeado las diversas soluciones a continuación y he creado una prueba jsperf .




jQuery también ofrece un $.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>




Imagina que tienes esta matriz a continuación:

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

Javascript (navegadores nuevos y antiguos):

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

o

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

o

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

entonces llámalo así:

isArray(arr);

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

Array.isArray(arr);

jQuery:

$.isArray(arr);

Angular:

angular.isArray(arr);

Subrayado y Lodash:

_.isArray(arr);



Función simple para comprobar esto:

function isArray(object)
{
    if (object.constructor === Array) return true;
    else return false;
}



Como dice MDN aquí :

use Array.isArray o Object.prototype.toString.call para diferenciar los objetos regulares de las matrices

Me gusta esto:

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

  • Array.isArray(arr)




Haría una función para probar el tipo de objeto con el que está tratando ...

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

entonces puedes escribir una simple declaración if ...

if(whatAmI(myVar) === "Array"){
    // do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
    // do string stuff
}



Hago esto de una manera muy simple. Funciona para mi. ¿Algún inconveniente?

Array.prototype.isArray = true;

a=[]; b={};
a.isArray  // true
b.isArray  // (undefined -> false)



Array.isArray

Array.isArray = Array.isArray || function (vArg) {
    return Object.prototype.toString.call(vArg) === "[object Array]";
};



Sé que la gente está buscando algún tipo de enfoque de javascript en bruto. Pero si quiere pensar menos, eche un vistazo aquí: http://underscorejs.org/#isArray

_.isArray(object) 

Devuelve true si el objeto es un Array.

(function(){ return _.isArray(arguments); })();
=> false
_.isArray([1,2,3]);
=> true



Aquí está mi enfoque perezoso:

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

// ...

var test = [],
    wat = {};

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

Sé que es un sacrilegio "meterse con" el prototipo, pero parece tener un rendimiento significativamente mejor que el método recomendado para la toString .

Nota: un inconveniente de este enfoque es que no funcionará a través de los límites de iframe , pero para mi caso de uso esto no es un problema.




Podrías usar el método isArray pero preferiría consultar con

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




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



Esta función convertirá casi cualquier cosa en una matriz:

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

Utiliza algunas funciones más nuevas del navegador, por lo que es posible que desee realizar un relleno múltiple para obtener el máximo soporte.

Ejemplos:

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

Las cadenas NB se convertirán en una matriz con un solo elemento en lugar de una matriz de caracteres. Elimine la verificación isString si lo prefiere al revés.

He usado Array.isArray aquí porque es el más robusto y también el más simple.




Se puede usar lo siguiente si sabe que su objeto no tiene un método concat.

var arr = [];
if (typeof arr.concat === 'function') {
    console.log("It's an array");
}




Puedes probar esto:

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

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

obj.constructor.prototype.hasOwnProperty('push') // false



Related