¿Cómo se comprueba si una variable es una matriz en JavaScript? [duplicar]

Hay varias formas de comprobar si una variable es una matriz o no. La mejor solución es la que ha elegido.

variable.constructor === Array

Este es el método más rápido en Chrome y muy probablemente en todos los demás navegadores. Todas las matrices son objetos, por lo que comprobar la propiedad del constructor es un proceso rápido para los motores JavaScript.

Si tiene problemas para averiguar si la propiedad de un objeto es una matriz, primero debe verificar si la propiedad está allí.

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

Algunas otras formas son:

Array.isArray(variable)

Actualización 23 de mayo de 2019 usando Chrome 75, un saludo a @AnduAndrici por hacerme revisar esto con su pregunta Este último es, en mi opinión, el más feo, y es uno de los el más lento lo más rápido. Corriendo aproximadamente 1/5 de la velocidad como primer ejemplo. Este tipo es aproximadamente un 2-5% más lento, pero es bastante difícil de decir. ¡Sólido para usar! Muy impresionado por el resultado. Array.prototype, es en realidad una matriz. Puedes leer más sobre esto aquí https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray

variable instanceof Array

Este método corre sobre 1/3 de la velocidad como primer ejemplo. Sigue siendo bastante sólido, se ve más limpio, si lo que te gusta es el código bonito y no tanto el rendimiento. Tenga en cuenta que la comprobación de números no funciona como variable instanceof Number siempre vuelve false. Actualizar: instanceof ahora va a 2/3 de la velocidad!

Así que otra actualización más

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

Este tipo es el más lento para intentar buscar una matriz. Sin embargo, esta es una ventanilla única para cualquier tipo que esté buscando. Sin embargo, dado que está buscando una matriz, simplemente use el método más rápido anterior.

Además, realicé una prueba: http://jsperf.com/instanceof-array-vs-array-isarray/35 Así que diviértete y compruébalo.

Nota: @EscapeNetscape ha creado otra prueba ya que jsperf.com está inactivo. http://jsben.ch/#/QgYAV Quería asegurarme de que el enlace original permanezca siempre que jsperf vuelva a estar en línea.

También puedes usar:

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

Esta me parece una solución bastante elegante, pero para cada uno lo suyo.

Edit:

A partir de ES5, ahora también hay:

Array.isArray(value);

Pero esto se romperá en los navegadores más antiguos, a menos que esté usando polyfills (básicamente ... IE8 o similar).

Existen múltiples soluciones con todas sus peculiaridades. En esta página ofrece una buena descripción general. Una posible solución es:

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

Noté que alguien mencionó jQuery, pero no sabía que había un isArray() función. Resulta que se agregó en la versión 1.3.

jQuery lo implementa como sugiere Peter:

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

Habiendo puesto mucha fe en jQuery (especialmente en sus técnicas para la compatibilidad entre navegadores), actualizaré a la versión 1.3 y usaré su función (siempre que la actualización no cause demasiados problemas) o usaré este método sugerido directamente en mi código.

Muchas gracias por las sugerencias.

En los navegadores modernos (y algunos navegadores heredados), puede hacer

Array.isArray(obj)

(Apoyado por Chrome 5, Firefox 4.0, IE 9, Opera 10.5 y Safari 5)

Si necesita admitir versiones anteriores de IE, puede usar es5-calce para polyfill Array.isArray; o agrega lo siguiente

# 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 usa jQuery puede usar jQuery.isArray(obj) or $.isArray(obj). Si usa guión bajo, puede usar _.isArray(obj)

Si no necesita detectar matrices creadas en diferentes marcos, también puede usar instanceof

obj instanceof Array

Nota: el arguments La palabra clave que se puede usar para acceder al argumento de una función no es una matriz, aunque (generalmente) se comporta como una:

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)

Esta es una pregunta antigua, pero al tener el mismo problema, encontré una solución muy elegante que quiero compartir.

Agregar un prototipo a Array lo hace muy simple

Array.prototype.isArray = true;

Ahora, una vez, si tiene un objeto que desea probar para ver si es una matriz, todo lo que necesita es verificar la nueva propiedad

var box = doSomething();

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

isArray solo está disponible si es una matriz

Vía Crockford:

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

La principal falla que menciona Crockford es la incapacidad de determinar correctamente las matrices que se crearon en un contexto diferente, por ejemplo, window. Esa página tiene una versión mucho más sofisticada si esta es insuficiente.

Si solo está tratando con EcmaScript 5 y superior, puede usar el Array.isArray función

e.g.,

Array.isArray([])    // true
Array.isArray("foo") // false
Array.isArray({})    // false

Personalmente, me gusta la sugerencia de Peter: https://stackoverflow.com/a/767499/414784 (para ECMAScript 3. Para ECMAScript 5, utilice Array.isArray())

Los comentarios en la publicación indican, sin embargo, que si toString() cambia en absoluto, esa forma de verificar una matriz fallará. Si realmente quiere ser específico y asegúrese toString() no se ha cambiado y no hay problemas con el atributo de clase de objetos ([object Array] es el atributo de clase de un objeto que es una matriz), entonces recomiendo hacer algo como esto:

//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; 
    }
}

Tenga en cuenta que en JavaScript The Definitive Guide 6th edition, 7.10, dice Array.isArray() se implementa usando Object.prototype.toString.call() en ECMAScript 5. También tenga en cuenta que si va a preocuparse por toString()Si cambia la implementación, también debe preocuparse por cualquier otro método integrado que cambie. Por que usar push()? ¡Alguien puede cambiarlo! Tal enfoque es una tontería. El cheque anterior es una solución ofrecida a aquellos preocupados por toString() cambiando, pero creo que el cheque es innecesario.

Cuando publiqué esta pregunta, la versión de JQuery que estaba usando no incluía un isArray función. Si lo hubiera hecho, probablemente lo habría usado confiando en que la implementación es la mejor forma independiente del navegador para realizar esta verificación de tipo en particular.

Dado que JQuery ahora ofrece esta función, siempre la usaría ...

$.isArray(obj);

(a partir de la versión 1.6.2) Todavía se implementa mediante comparaciones en cadenas en el formulario

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

Pensé que agregaría otra opción para aquellos que ya estén usando la biblioteca Underscore.js en su script. Underscore.js tiene una función isArray () (ver http://underscorejs.org/#isArray).

_.isArray(object) 

Devuelve verdadero si el objeto es una matriz.

Si está usando Angular, puede usar la función angular.isArray ()

var myArray = [];
angular.isArray(myArray); // returns true

var myObj = {};
angular.isArray(myObj); //returns false

http://docs.angularjs.org/api/ng/function/angular.isArray

En Crockford's JavaScript Las buenas partes, hay una función para verificar si el argumento dado es una matriz:

var is_array = function (value) {
    return value &&
        typeof value === 'object' &&
        typeof value.length === 'number' &&
        typeof value.splice === 'function' &&
        !(value.propertyIsEnumerable('length'));
};

El explica:

Primero, preguntamos si el valor es verdadero. Hacemos esto para rechazar valores nulos y otros valores falsos. En segundo lugar, preguntamos si el tipo de valor es 'objeto'. Esto será cierto para objetos, matrices y (extrañamente) nulos. En tercer lugar, preguntamos si el valor tiene una propiedad de longitud que sea un número. Esto siempre será cierto para las matrices, pero generalmente no para los objetos. Cuarto, preguntamos si el valor contiene un método de empalme. Esto nuevamente será cierto para todas las matrices. Finalmente, preguntamos si la propiedad length es enumerable (¿la longitud será producida por un bucle for in?). Eso será falso para todas las matrices. Esta es la prueba más confiable de matriz que he encontrado. Es una pena que sea tan complicado.

La solución universal está a continuación:

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

A partir de ECMAScript 5, una solución formal es:

Array.isArray(arr)

Además, para las antiguas bibliotecas de JavaScript, puede encontrar la siguiente solución, aunque no es lo suficientemente precisa:

var is_array = function (value) {
    return value &&
    typeof value === 'object' &&
    typeof value.length === 'number' &&
    typeof value.splice === 'function' &&
    !(value.propertyIsEnumerable('length'));
};

Las soluciones son de http://www.pixelstech.net/topic/85-How-to-check-whether-an-object-is-an-array-or-not-in-JavaScript

código referido desde https://github.com/miksago/Evan.js/blob/master/src/evan.js

  var isArray = Array.isArray || function(obj) {
    return !!(obj && obj.concat && obj.unshift && !obj.callee);};

Estaba usando esta línea de código:

if (variable.push) {
   // variable is array, since AMAIK only arrays have push() method.
}

Para aquellos que codifican golf, una prueba poco confiable con la menor cantidad de caracteres:

function isArray(a) {
  return a.map;
}

Esto se usa comúnmente al atravesar / aplanar una jerarquía:

function golf(a) {
  return a.map?[].concat.apply([],a.map(golf)):a;
}

input: [1,2,[3,4,[5],6],[7,[8,[9]]]]
output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Desde w3schools:

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

Me gustó la respuesta de Brian:

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

pero podrías hacer lo siguiente:

return Object.prototype.toString.call(o) === Object.prototype.toString.call([]);

He creado este pequeño código, que puede devolver tipos verdaderos.

Todavía no estoy seguro del rendimiento, pero es un intento de identificar correctamente el tipo de.

https://github.com/valtido/better-typeOf También escribí un poco sobre esto aquí. http://www.jqui.net/jquery/better-typeof-than-the-javascript-native-typeof/

funciona, similar al typeof actual.

var user = [1,2,3]
typeOf(user); //[object Array]

Creo que puede necesitar un poco de ajuste fino, y teniendo en cuenta las cosas, no lo he encontrado ni lo he probado correctamente. por lo que se agradecen más mejoras, ya sea en términos de rendimiento o de informes incorrectos de typeOf.

Creo que usar myObj.constructor == Object y myArray.constructor == Array es la mejor manera. Es casi 20 veces más rápido que usar toString (). Si extiendes objetos con tus propios constructores y quieres que esas creaciones también se consideren "objetos", esto no funciona, pero por lo demás es mucho más rápido. typeof es tan rápido como el método constructor pero typeof [] == 'object' devuelve verdadero, lo que a menudo no es deseable. http://jsperf.com/constructor-vs-tostring

una cosa a tener en cuenta es que null.constructor arrojará un error, por lo que si está buscando valores nulos, primero tendrá que hacer if (testThing! == null) {}

Dado que la propiedad .length es especial para matrices en javascript, simplemente puede decir

obj.length === +obj.length // true if obj is an array

Underscorejs y varias otras bibliotecas utilizan este breve y sencillo truco.

Algo que acabo de pensar:

if (item.length) //This is an array else //not an array