Como detectar se uma variável é um array

Qual é o melhor método cruzado padrão de fato para determinar se uma variável em JavaScript é um array ou não?

Pesquisando na web há várias sugestões diferentes, algumas boas e outras inválidas.

Por exemplo, o seguinte é uma abordagem básica:

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

No entanto, observe o que acontece se a matriz estiver vazia, ou obj realmente não for uma matriz, mas implementar uma propriedade de comprimento, etc.

Então, qual implementação é a melhor em termos de realmente funcionar, ser cross-browser e ainda ter um desempenho eficiente?

A verificação de tipo de objetos em JS é feita via instanceof, ou seja,

obj instanceof Array

Isso não funcionará se o objeto for passado pelos limites do quadro, pois cada quadro tem seu próprio Arrayobjeto. Você pode contornar isso verificando a propriedade interna [[Class]] do objeto. Para obtê-lo, use Object.prototype.toString()(é garantido que funcione pela ECMA-262):

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

Ambos os métodos funcionarão apenas para arrays reais e não para objetos do tipo array, como o argumentsobjeto ou listas de nós. Como todos os objetos em forma de matriz devem ter uma lengthpropriedade numérica , eu verificaria assim:

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

Observe que as strings passarão nesta verificação, o que pode causar problemas, pois o IE não permite acesso aos caracteres de uma string por índice. Portanto, você pode querer alterar typeof obj !== 'undefined'para typeof obj === 'object'para excluir primitivos e objetos de host com tipos diferentes de todos 'object'juntos. Isso ainda permitirá a passagem de objetos de string, que teriam que ser excluídos manualmente.

Na maioria dos casos, o que você realmente deseja saber é se pode iterar sobre o objeto por meio de índices numéricos. Portanto, pode ser uma boa ideia verificar se o objeto tem uma propriedade chamada 0, o que pode ser feito por meio de uma destas verificações:

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

A conversão para o objeto é necessária para funcionar corretamente para primitivos do tipo array (ou seja, strings).

Este é o código para verificações robustas para matrizes JS:

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

e objetos semelhantes a array iteráveis ​​(ou seja, não vazios):

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

A chegada do ECMAScript 5th Edition nos dá o método mais seguro de testar se uma variável é uma matriz, Array.isArray () :

Array.isArray([]); // true

Embora a resposta aceita aqui funcione em frames e janelas para a maioria dos navegadores, não funciona para o Internet Explorer 7 e inferior , porque Object.prototype.toStringuma matriz chamada de uma janela diferente retornará [object Object], não [object Array]. O IE 9 também parece ter regredido a esse comportamento (consulte a correção atualizada abaixo).

Se quiser uma solução que funcione em todos os navegadores, você pode 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;
        }
    }
})();

Não é totalmente inquebrável, mas só seria quebrado por alguém que tentasse quebrá-lo. Ele contorna os problemas do IE7 e inferiores e do IE9. O bug ainda existe no IE 10 PP2 , mas pode ser corrigido antes do lançamento.

PS, se você não tiver certeza sobre a solução, então eu recomendo que você teste o que quiser e / ou leia a postagem do blog. Existem outras soluções possíveis se você não se sentir confortável com a compilação condicional.

Crockford tem duas respostas na página 106 de "The Good Parts". O primeiro verifica o construtor, mas fornecerá falsos negativos em diferentes frames ou janelas. Aqui está o segundo:

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

Crockford aponta que esta versão identificará o argumentsarray como um array, mesmo que não tenha nenhum dos métodos de array.

Sua interessante discussão do problema começa na página 105.

Há mais uma discussão interessante (pós-boas peças) aqui que inclui esta proposta:

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

Toda a discussão me faz nunca querer saber se algo é ou não um array.

jQuery implementa uma função isArray, que sugere que a melhor maneira de fazer isso é

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

(snippet retirado do jQuery v1.3.2 - ligeiramente ajustado para fazer sentido fora do contexto)

Roubando do guru John Resig e jquery:

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

O que você vai fazer com o valor depois de decidir que é uma matriz?

Por exemplo, se você pretende enumerar os valores contidos, se parecer uma matriz OU se for um objeto sendo usado como uma tabela hash, o código a seguir obtém o que você deseja (este código para quando a função de fechamento retorna qualquer outro do que "indefinido". Observe que ele NÃO itera em contêineres COM ou enumerações; isso é deixado como um exercício para o leitor):

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

(Observação: "o! = Null" testa tanto para nulo quanto para indefinido)

Exemplos 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] );
        }
    })
}

Se você estiver fazendo isso no CouchDB (SpiderMonkey), use

Array.isArray(array)

como array.constructor === Arrayou array instanceof Arraynão funcionam. Usar array.toString() === "[object Array]"funciona, mas parece muito duvidoso em comparação.

Se você quiser um navegador cruzado, deve jQuery.isArray .

No w3school, há um exemplo que deve ser bastante padrão.

Para verificar se uma variável é uma matriz, eles usam algo semelhante a este

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

testado no Chrome, Firefox, Safari, ie7

Uma das versões mais pesquisadas e discutidas dessa função pode ser encontrada no site do PHPJS . Você pode criar um link para pacotes ou ir diretamente para a função . Eu recomendo fortemente o site para equivalentes bem construídos de funções PHP em JavaScript.

Referência insuficiente igual aos construtores. Às vezes, eles têm diferentes referências de construtor. Então, eu uso representações de string deles.

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

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

amostras:

Array('44','55').constructor==Array retornar verdadeiro (IE8 / Chrome)

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