Cómo detectar si una variable es una matriz

¿Cuál es el mejor método estándar de facto entre navegadores para determinar si una variable en JavaScript es una matriz o no?

Al buscar en la web, hay una serie de sugerencias diferentes, algunas buenas y algunas no válidas.

Por ejemplo, el siguiente es un enfoque básico:

function isArray(obj) {
    return (obj && obj.length);
}

Sin embargo, tenga en cuenta lo que sucede si la matriz está vacía, o si obj en realidad no es una matriz, pero implementa una propiedad de longitud, etc.

Entonces, ¿qué implementación es la mejor en términos de funcionar realmente, ser entre navegadores y seguir funcionando de manera eficiente?

La verificación de tipos de objetos en JS se realiza mediante instanceof, es decir

obj instanceof Array

Esto no funcionará si el objeto pasa a través de los límites del marco, ya que cada marco tiene su propio Arrayobjeto. Puede solucionar este problema comprobando la propiedad [[Class]] interna del objeto. Para obtenerlo, utilice Object.prototype.toString()(ECMA-262 garantiza que funciona):

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

Ambos métodos solo funcionarán para matrices reales y no para objetos similares a matrices como el argumentsobjeto o las listas de nodos. Como todos los objetos tipo matriz deben tener una lengthpropiedad numérica , verificaría estos como este:

typeof obj !== 'undefined' && obj !== null && typeof obj.length === 'number'

Tenga en cuenta que las cadenas pasarán esta verificación, lo que podría generar problemas ya que IE no permite el acceso a los caracteres de una cadena por índice. Por lo tanto, es posible que desee cambiar typeof obj !== 'undefined'a typeof obj === 'object'para excluir primitivas y objetos host con tipos distintos de todos 'object'juntos. Esto todavía permitirá que pasen los objetos de cadena, que deberían excluirse manualmente.

En la mayoría de los casos, lo que realmente desea saber es si puede iterar sobre el objeto mediante índices numéricos. Por lo tanto, podría ser una buena idea verificar si el objeto tiene una propiedad nombrada 0en su lugar, lo que se puede hacer a través de una de estas verificaciones:

typeof obj[0] !== 'undefined' // false negative for `obj[0] = undefined`
obj.hasOwnProperty('0') // exclude array-likes with inherited entries
'0' in Object(obj) // include array-likes with inherited entries

La conversión a objeto es necesaria para que funcione correctamente para primitivas de tipo arreglo (es decir, cadenas).

Aquí está el código para comprobaciones sólidas para matrices JS:

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

y objetos similares a matrices iterables (es decir, no vacíos):

function isNonEmptyArrayLike(obj) {
    try { // don't bother with `typeof` - just access `length` and `catch`
        return obj.length > 0 && '0' in Object(obj);
    }
    catch(e) {
        return false;
    }
}

La llegada de ECMAScript 5th Edition nos brinda el método de prueba más seguro si una variable es una matriz, Array.isArray () :

Array.isArray([]); // true

Si bien la respuesta aceptada aquí funcionará en marcos y ventanas para la mayoría de los navegadores, no es así para Internet Explorer 7 y versiones anteriores , ya que Object.prototype.toStringse devolverá la llamada en una matriz desde una ventana diferente [object Object], no [object Array]. IE 9 parece haber regresado a este comportamiento también (consulte la corrección actualizada a continuación).

Si desea una solución que funcione en todos los navegadores, puede usar:

(function () {
    var toString = Object.prototype.toString,
        strArray = Array.toString(),
        jscript  = /*@cc_on @_jscript_version @*/ +0;

    // jscript will be 0 for browsers other than IE
    if (!jscript) {
        Array.isArray = Array.isArray || function (obj) {
            return toString.call(obj) == "[object Array]";
        }
    }
    else {
        Array.isArray = function (obj) {
            return "constructor" in obj && String(obj.constructor) == strArray;
        }
    }
})();

No es del todo irrompible, pero solo alguien que se esfuerce por romperlo lo romperá. Resuelve los problemas en IE7 y versiones inferiores e IE9. El error aún existe en IE 10 PP2 , pero podría corregirse antes del lanzamiento.

PD, si no está seguro acerca de la solución, le recomiendo que la pruebe con el contenido de su corazón y / o lea la publicación del blog. Hay otras posibles soluciones allí si no se siente cómodo con la compilación condicional.

Crockford tiene dos respuestas en la página 106 de "Las partes buenas". El primero verifica el constructor, pero dará falsos negativos en diferentes marcos o ventanas. Aquí está el segundo:

if (my_value && typeof my_value === 'object' &&
        typeof my_value.length === 'number' &&
        !(my_value.propertyIsEnumerable('length')) {
    // my_value is truly an array!
}

Crockford señala que esta versión identificará la argumentsmatriz como una matriz, aunque no tenga ninguno de los métodos de matriz.

Su interesante discusión sobre el problema comienza en la página 105.

Hay más discusión interesante (post-Good Parts) aquí que incluye esta propuesta:

var isArray = function (o) {
    return (o instanceof Array) ||
        (Object.prototype.toString.apply(o) === '[object Array]');
};

Toda la discusión me hace no querer saber si algo es una matriz o no.

jQuery implementa una función isArray, que sugiere que la mejor manera de hacerlo es

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

(fragmento tomado de jQuery v1.3.2 - ligeramente ajustado para que tenga sentido fuera de contexto)

Robando al gurú John Resig y jquery:

function isArray(array) {
    if ( toString.call(array) === "[object Array]") {
        return true;
    } else if ( typeof array.length === "number" ) {
        return true;
    }
    return false;
}

¿Qué vas a hacer con el valor una vez que decidas que es una matriz?

Por ejemplo, si tiene la intención de enumerar los valores contenidos si se ve como una matriz O si es un objeto que se usa como una tabla hash, entonces el siguiente código obtiene lo que desea (este código se detiene cuando la función de cierre devuelve cualquier otra cosa que "indefinido". Tenga en cuenta que NO itera sobre contenedores COM o enumeraciones; eso se deja como un ejercicio para el lector):

function iteratei( o, closure )
{
    if( o != null && o.hasOwnProperty )
    {
        for( var ix in seq )
        {
            var ret = closure.call( this, ix, o[ix] );
            if( undefined !== ret )
                return ret;
        }
    }
    return undefined;
}

(Nota: pruebas "o! = Null" tanto para nulo como para indefinido)

Ejemplos de uso:

// Find first element who's value equals "what" in an array
var b = iteratei( ["who", "what", "when" "where"],
    function( ix, v )
    {
        return v == "what" ? true : undefined;
    });

// Iterate over only this objects' properties, not the prototypes'
function iterateiOwnProperties( o, closure )
{
    return iteratei( o, function(ix,v)
    {
        if( o.hasOwnProperty(ix) )
        {
            return closure.call( this, ix, o[ix] );
        }
    })
}

Si está haciendo esto en CouchDB (SpiderMonkey), use

Array.isArray(array)

como array.constructor === Arrayo array instanceof Arrayno funcionan. El uso array.toString() === "[object Array]"funciona, pero parece bastante dudoso en comparación.

Si desea varios navegadores, desea jQuery.isArray .

En w3school hay un ejemplo que debería ser bastante estándar.

Para verificar si una variable es una matriz, usan algo similar a esto

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

probado en Chrome, Firefox, Safari, ie7

Una de las versiones mejor investigadas y discutidas de esta función se puede encontrar en el sitio PHPJS . Puede vincular a paquetes o puede ir directamente a la función . Recomiendo encarecidamente el sitio para obtener equivalentes bien construidos de funciones PHP en JavaScript.

No hay suficientes referencias iguales de constructores. En algún momento tienen diferentes referencias de constructor. Entonces uso representaciones de cadenas de ellos.

function isArray(o) {
    return o.constructor.toString() === [].constructor.toString();
}

Reemplazar Array.isArray(obj)porobj.constructor==Array

muestras:

Array('44','55').constructor==Array devuelve verdadero (IE8 / Chrome)

'55'.constructor==Array devolver falso (IE8 / Chrome)