Como verificar se um objeto é uma matriz?

Estou tentando escrever uma função que aceita uma lista de seqüências de caracteres ou uma única seqüência de caracteres. Se for uma string, quero convertê-la em uma matriz com apenas um item, para que eu possa fazer um loop sobre ela sem medo de erro.

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

Reuni as várias soluções abaixo e criei um teste jsperf . Eles são todos rápidos, portanto, basta usar Array.isArray- ele é bem suportado agora e funciona em vários quadros .

Nos navegadores modernos, você pode fazer

Array.isArray(obj)

( Suportado pelo Chrome 5, Firefox 4.0, IE 9, Opera 10.5 e Safari 5)

Para compatibilidade com versões anteriores, você pode adicionar o seguinte

# only implement if no native implementation is available
if (typeof Array.isArray === 'undefined') {
  Array.isArray = function(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  }
};

Se você usa jQuery, pode usar jQuery.isArray(obj)ou $.isArray(obj). Se você usar sublinhado, poderá usar_.isArray(obj)

Se você não precisa detectar matrizes criadas em quadros diferentes, também pode usar instanceof

obj instanceof Array

O método fornecido no padrão ECMAScript para encontrar a classe de Object é usar o toStringmétodo de Object.prototype.

if( Object.prototype.toString.call( someVar ) === '[object Array]' ) {
    alert( 'Array!' );
}

Ou você pode usar typeofpara testar se é uma String:

if( typeof someVar === 'string' ) {
    someVar = [ someVar ];
}

Ou, se você não está preocupado com o desempenho, basta fazer um concatpara uma nova matriz vazia.

someVar = [].concat( someVar );

Há também o construtor que você pode consultar diretamente:

if (somevar.constructor.name == "Array") {
    // do something
}

Confira um tratamento completo no blog de @TJ Crowder , conforme publicado em seu comentário abaixo.

Confira este benchmark para ter uma idéia de qual método tem melhor desempenho: http://jsben.ch/#/QgYAV

De @Bharath, converta string em array usando Es6 para a pergunta:

const convertStringToArray = (object) => {
   return (typeof object === 'string') ? Array(object) : object 
}

suponha:

let m = 'bla'
let n = ['bla','Meow']
let y = convertStringToArray(m)
let z = convertStringToArray(n)
console.log('check y: '+JSON.stringify(y)) . // check y: ['bla']
console.log('check y: '+JSON.stringify(z)) . // check y: ['bla','Meow']

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

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

Você também pode tentar usar o instanceofoperador

v instanceof Array

O jQuery também oferece um $.isArray()método:

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>

Este é o mais rápido entre todos os métodos (todos os navegadores suportados):

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

Imagine que você tem esta matriz 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 chame assim:

isArray(arr);

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

Array.isArray(arr);

jQuery:

$.isArray(arr);

Angular:

angular.isArray(arr);

Sublinhado e Lodash:

_.isArray(arr);

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

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

Função simples para verificar isso:

function isArray(object)
{
    return object.constructor === Array;
}

Como a MDN diz aqui :

use Array.isArray ou Object.prototype.toString.call para diferenciar objetos regulares de matrizes

Como isso:

• Object.prototype.toString.call(arr) === '[object Array]'ou

• Array.isArray(arr)

Existe apenas uma solução de linha para esta pergunta

x instanceof Array

onde x é a variável, retornará true se x for uma matriz e false se não for.

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

var myArray=[];

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

Eu faria uma função para testar o tipo de objeto com o qual você está lidando ...

function whatAmI(me){ return Object.prototype.toString.call(me).split(/\W/)[2]; }

// tests
console.log(
  whatAmI(["aiming","@"]),
  whatAmI({living:4,breathing:4}),
  whatAmI(function(ing){ return ing+" to the global window" }),
  whatAmI("going to do with you?")
);

// output: Array Object Function String

então você pode escrever uma declaração if simples ...

if(whatAmI(myVar) === "Array"){
    // do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
    // do string stuff
}

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)

Esta é minha tentativa de melhorar esta resposta, levando em consideração os comentários:

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

Ele se livra do if / else e explica a possibilidade de o array ser nulo ou indefinido

https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/isArray

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

Atualizei o jsperf fiddle com dois métodos alternativos, bem como com a verificação de erros.

Acontece que o método que define um valor constante nos protótipos 'Objeto' e 'Matriz' é mais rápido que qualquer outro método. É um resultado um tanto 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 funcionarão se você tiver certeza de que eles têm um valor. Com relação à verificação com o desempenho em mente se um valor é uma matriz ou um valor único, o segundo método se parece com um método rápido válido. É um pouco mais rápido que '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 sei que as pessoas estão procurando algum tipo de abordagem javascript bruta. Mas se você quiser pensar 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

A melhor solução que eu vi é uma substituição entre navegadores do typeof. Confira a solução da Angus Croll aqui .

A versão TL; DR está abaixo, mas o artigo é uma ótima discussão sobre o problema; portanto, 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 */};

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

Sei que é um sacrilégio "mexer com" o protótipo, mas ele parece ter um desempenho significativamente melhor que o toStringmétodo recomendado .

Nota: Uma armadilha dessa abordagem é que ela não funcionará além dos iframelimites , mas para o meu caso de uso isso não é um problema.

Há um bom exemplo no livro JavaScript Patterns, de Stoyan Stefanov, que supõe lidar com todos os problemas possíveis, além de utilizar 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 jQuery, poderá usar o método $ .isArray ()

A maneira mais fácil e rápida de verificar se um Objeto é uma Matriz ou não.

 var arr = [];
  arr.constructor.name ==='Array'  //return true;

ou

arr.constructor ===Array //return true;

ou você pode fazer uma função de utilitário:

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

uso:

isArray(arr); //return true

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

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

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

Se os únicos dois tipos de valores que podem ser passados ​​para essa função são uma sequência ou uma matriz de sequências, mantenha-a simples e use uma typeofverificação da possibilidade de sequência:

function someFunc(arg) {
    var arr = (typeof arg == "string") ? [arg] : arg;
}

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

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

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

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

var ar = ["ff","tt"]
alert(isArray(ar))

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

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

Isso funciona em vários navegadores e com navegadores mais antigos. Isso é retirado da postagem do blog de TJ Crowders

Você pode tentar isso:

var arr = []; (or) arr = new Array();
var obj = {}; (or) arr = new Object();

arr.constructor.prototype.hasOwnProperty('push') //true

obj.constructor.prototype.hasOwnProperty('push') // false

Esta função transformará quase tudo em uma matriz:

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, portanto, você pode preencher isso para obter o máximo suporte.

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

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

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

No seu caso, você pode usar o concatmétodo Array, que pode aceitar objetos únicos e também array (e até combinado):

function myFunc(stringOrArray)
{
  var arr = [].concat(stringOrArray);

  console.log(arr);

  arr.forEach(function(item, i)
  {
    console.log(i, "=", item);
  })
}

myFunc("one string");

myFunc(["one string", "second", "third"]);

concat parece ser um dos métodos mais antigos do Array (até o IE 5.5 o conhece bem).