type - verificar se é objeto javascript




Verifique se o objeto é uma matriz? (20)

A melhor solução que vi é uma substituição entre navegadores para typeof. Verifique a solução de Angus Croll here .

A versão TL; DR está abaixo, mas o artigo é uma ótima discussão do problema, então você deve lê-lo se tiver tempo. 

Object.toType = function(obj) {
    return ({}).toString.call(obj).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();
}
// ... and usage:
Object.toType([1,2,3]); //"array" (all browsers)

// or to test...
var shouldBeAnArray = [1,2,3];
if(Object.toType(shouldBeAnArray) === 'array'){/* do stuff */};

Eu estou tentando escrever uma função que aceita uma lista de seqüências de caracteres ou uma única seqüência de caracteres. Se é uma string, então eu quero convertê-lo em um array com apenas um item. Então eu posso passar por cima sem medo de um erro.

Então, como posso verificar se a variável é uma matriz?

Arredorgei as várias soluções abaixo e criei um teste jsperf .

Aqui está minha abordagem preguiçosa: 

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

// ...

var test = [],
    wat = {};

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

Eu sei que é um sacrilégio "mexer com" o protótipo, mas ele parece ter um desempenho significativamente melhor do que o método toString recomendado .

Nota: Uma armadilha dessa abordagem é que ela não funcionará em todos os limites de iframe , mas, para meu caso de uso, isso não é um problema.

Esta é a minha tentativa de melhorar esta resposta, tendo em conta os comentários: 

var isArray = myArray && myArray.constructor === Array;

Ele elimina o if / else e considera a possibilidade de o array ser nulo ou indefinido

Esta função irá transformar quase tudo em um array: 

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

Ele usa alguns recursos mais recentes do navegador, então você pode querer polyfill isso para o máximo apoio.

Exemplos: 

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

Seqüências NB serão convertidas em uma matriz com um único elemento em vez de uma matriz de caracteres. Exclua a verificação isString se preferir o contrário.

Eu usei Array.isArray aqui porque é o mais robusto e também o mais simples.

Eu atualizei o violino jsperf com dois métodos alternativos, bem como a verificação de erros.

Acontece que o método que define um valor constante nos protótipos 'Object' e 'Array' é mais rápido do que qualquer outro método. É um resultado surpreendente. 

/* Initialisation */
Object.prototype.isArray = function() {
  return false;
};
Array.prototype.isArray = function() {
  return true;
};
Object.prototype._isArray = false;
Array.prototype._isArray = true;

var arr = ["1", "2"];
var noarr = "1";

/* Method 1 (function) */
if (arr.isArray()) document.write("arr is an array according to function<br/>");
if (!noarr.isArray()) document.write("noarr is not an array according to function<br/>");
/* Method 2 (value) - **** FASTEST ***** */
if (arr._isArray) document.write("arr is an array according to member value<br/>");
if (!noarr._isArray) document.write("noarr is not an array according to member value<br/>");

Esses dois métodos não funcionam se a variável receber o valor indefinido, mas funcionam se você tiver certeza de que eles têm um valor. Com relação à verificação com o desempenho em mente, se um valor for uma matriz ou um valor único, o segundo método será semelhante a um método rápido válido. É ligeiramente mais rápido que o 'instanceof' no Chrome, duas vezes mais rápido que o segundo melhor método no Internet Explorer, Opera e Safari (na minha máquina).

Eu faço isso de uma maneira muito simples. Funciona para mim. Alguma desvantagem? 

Array.prototype.isArray = true;

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

Eu sei, que as pessoas estão procurando por algum tipo de abordagem javascript bruta. Mas se você quiser menos, dê uma olhada aqui: http://underscorejs.org/#isArray 

_.isArray(object)

Retorna true se o objeto for uma matriz. 

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

Função simples para verificar isso: 

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

Há um bom exemplo no livro JavaScript Patterns, de Stoyan Stefanov, que supostamente lida com todos os possíveis problemas, bem como utiliza o método Array.isArray () do ECMAScript 5.

Então aqui está: 

if (typeof Array.isArray === "undefined") {
    Array.isArray = function (arg) {
        return Object.prototype.toString.call(arg) === "[object Array]";
    };
}

A propósito, se você estiver usando o jQuery, você pode usar o método $.isArray()

Imagine que você tenha este array abaixo: 

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

Javascript (navegadores novos e antigos): 

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

ou 

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

ou 

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

então ligue assim: 

isArray(arr);

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

Array.isArray(arr);

jQuery: 

$.isArray(arr);

Angular: 

angular.isArray(arr);

Underscore e Lodash: 

_.isArray(arr);

O Array.isArray funciona rápido, mas não é suportado por todas as versões de navegadores. Então você pode fazer uma exceção para os outros e usar o método universal: 

    Utils = {};    
    Utils.isArray = ('isArray' in Array) ? 
        Array.isArray : 
        function (value) {
            return Object.prototype.toString.call(value) === '[object Array]';
        }

O jQuery também oferece um método $.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>

O seguinte pode ser usado se você souber que seu objeto não possui um método concat. 

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

Primeiro, verifiquei se sua implementação suporta isArray : 

if (Array.isArray)
    return Array.isArray(v);

Você também pode tentar usar o operador instanceof 

v instanceof Array

Uma função simples para testar se um valor de entrada é um array é o seguinte: 

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

Isso funciona no navegador e em navegadores mais antigos. Isso é retirado da postagem no blog de TJ Crowders

Você pode verificar o tipo de sua variável se é uma matriz com; 

var myArray=[];

if(myArray instanceof Array)
{
....
}

Você poderia é o método isArray, mas eu preferiria verificar com

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

Array.isArray 

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

A = [1,2,3]
console.log(A.map==[].map)

Em busca da versão mais curta, aqui está o que cheguei até agora.

Note que não existe uma função perfeita que detecte sempre todas as combinações possíveis. É melhor conhecer todas as habilidades e limitações de suas ferramentas do que esperar uma ferramenta mágica.




verificar   type   objetos   objeto   not   array   javascript   arrays  


arrays