javascript - objetos - mozilla developer array




Como você verifica se uma variável é uma matriz em JavaScript? (16)

A solução universal está abaixo:

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

A partir do ECMAScript 5, uma solução formal é:

Array.isArray(arr)

Além disso, para bibliotecas antigas de JavaScript, você pode encontrar a solução abaixo, embora não seja preciso o suficiente:

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

As soluções são de http://www.pixelstech.net/topic/85-How-to-check-whether-an-object-is-an-array-or-not-in-JavaScript

Esta questão já tem uma resposta aqui:

Gostaria de verificar se uma variável é uma matriz ou um valor único em JavaScript.

Eu encontrei uma solução possível ...

if (variable.constructor == Array)...

Essa é a melhor maneira de fazer isso?


Algo que acabei de inventar:

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


De w3schools :

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

Esta é uma pergunta antiga, mas com o mesmo problema eu encontrei uma solução muito elegante que eu quero compartilhar.

Adicionando um protótipo para Array torna muito simples

Array.prototype.isArray = true;

Agora, uma vez, se você tiver um objeto que deseja testar para ver se é um array, tudo o que você precisa é verificar a nova propriedade

var box = doSomething();

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

isArray só está disponível se for um array


Eu criei este pequeno código, que pode retornar tipos verdadeiros.

Ainda não tenho certeza sobre o desempenho, mas é uma tentativa de identificar corretamente o tipo.

https://github.com/valtido/better-typeOf também blogou um pouco sobre isso aqui http://www.jqui.net/jquery/better-typeof-than-the-javascript-native-typeof/

funciona, semelhante ao tipo atual.

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

Acho que pode precisar de um pouco de ajuste fino, e levar em conta as coisas, eu não encontrei ou testei corretamente. Assim, outras melhorias são bem-vindas, seja em termos de desempenho ou de forma incorreta, na reimportação do typeOf.


Eu estava usando esta linha de código:

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

Eu notei que alguém mencionou o jQuery, mas eu não sabia que havia uma função isArray() . Acontece que foi adicionado na versão 1.3.

jQuery implementa como Peter sugere:

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

Tendo acreditado muito no jQuery (especialmente em suas técnicas de compatibilidade entre navegadores), atualizarei para a versão 1.3 e utilizarei sua função (desde que a atualização não cause muitos problemas) ou use este método sugerido diretamente na minha conta. código.

Muito obrigado pelas sugestões.


Eu pessoalmente gosto da sugestão de Peter: https://.com/a/767499/414784 (para ECMAScript 3. Para o ECMAScript 5, use Array.isArray() )

Comentários no post indicam, no entanto, que se toString() for alterado, a maneira de verificar um array falhará. Se você realmente quer ser específico e ter certeza de que toString() não foi alterado, e não há problemas com o atributo de classe de objetos ( [object Array] é o atributo de classe de um objeto que é um array), então eu recomendo fazer algo assim:

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

Note que em JavaScript The Definitive Guide 6ª edição, 7.10, ele diz que Array.isArray() é implementado usando Object.prototype.toString.call() no ECMAScript 5. Observe também que se você vai se preocupar com toString() ' Como a implementação está mudando, você também deve se preocupar com todos os outros métodos incorporados. Por que usar o push() ? Alguém pode mudar isso! Tal abordagem é boba. A verificação acima é uma solução oferecida para aqueles preocupados com toString() mudando, mas acredito que o cheque é desnecessário.


Existem várias soluções com todas as suas peculiaridades. Esta página fornece uma boa visão geral. Uma solução possível é:

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

No JavaScript de Crockford, The Good Parts , existe uma função para verificar se o argumento dado é um array:

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

Ele explica:

Primeiro, perguntamos se o valor é verdadeiro. Fazemos isso para rejeitar valores nulos e outros valores falsos. Em segundo lugar, perguntamos se o tipo de valor é 'objeto'. Isso será verdade para objetos, matrizes e (estranhamente) nulo. Terceiro, perguntamos se o valor tem uma propriedade de comprimento que é um número. Isso sempre será verdadeiro para matrizes, mas geralmente não para objetos. Quarto, perguntamos se o valor contém um método de emenda. Isso novamente será verdade para todos os arrays. Finalmente, perguntamos se a propriedade length é enumerável (o comprimento será produzido por um loop in?). Isso será falso para todos os arrays. Este é o teste mais confiável para arrayness que eu encontrei. É uma pena que seja tão complicado.


Para aqueles que codificam golfe, um teste não confiável com menos caracteres:

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

Isso é comumente usado ao percorrer / achatar uma hierarquia:

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]

Pensei em adicionar outra opção para aqueles que já podem estar usando a biblioteca Underscore.js em seu script. Underscore.js tem uma função isArray () (veja http://underscorejs.org/#isArray ).

_.isArray(object) 

Retorna true se o objeto for uma matriz.


Se você está lidando apenas com o EcmaScript 5 e acima, então você pode usar a função Array.isArray embutida

por exemplo,

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


Você também pode usar:

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

Isto parece-me uma solução bastante elegante, mas para cada um deles.

Editar:

A partir do ES5 existe agora também:

Array.isArray(value);

Mas isso vai quebrar em navegadores mais antigos, a menos que você esteja usando polyfills (basicamente ... IE8 ou similar).






variables