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 tentar esta abordagem: http://web.archive.org/web/20100424091244/http://www.ajaxdr.com/code/javascript-version-of-phps-is_array-function/
EDIT : também, se você já estiver usando o JQuery em seu projeto, você pode usar sua função $.isArray() .
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 || 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.