¿Cómo verificar si un objeto es una matriz?

Estoy tratando de escribir una función que acepte una lista de cadenas o una sola cadena. Si es una cadena, entonces quiero convertirla en una matriz con solo un elemento, para poder recorrerla sin temor a un error.

Entonces, ¿cómo verifico si la variable es una matriz?

He redondeado las diversas soluciones a continuación y he creado una prueba jsperf . Todos son rápidos, así que solo úselos Array.isArray, ahora está bien soportado y funciona en todos los marcos .

En los navegadores modernos puedes hacer

Array.isArray(obj)

( Compatible con Chrome 5, Firefox 4.0, IE 9, Opera 10.5 y Safari 5)

Para compatibilidad con versiones anteriores, puede agregar lo siguiente

# 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]';
  }
};

Si usa jQuery puede usar jQuery.isArray(obj)o $.isArray(obj). Si usa guión bajo, puede usar_.isArray(obj)

Si no necesita detectar arreglos creados en diferentes marcos, también puede usar instanceof

obj instanceof Array

El método dado en el estándar ECMAScript para encontrar la clase de Objeto es usar el toStringmétodo desde Object.prototype.

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

O podría usar typeofpara probar si es una cadena:

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

O si no está preocupado por el rendimiento, puede simplemente hacer una concata una nueva matriz vacía.

someVar = [].concat( someVar );

También está el constructor que puede consultar directamente:

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

Echa un vistazo a un tratamiento exhaustivo del blog de @TJ Crowder , como se publica en su comentario a continuación.

Consulte este punto de referencia para tener una idea de qué método funciona mejor: http://jsben.ch/#/QgYAV

De @Bharath convierte una cadena a una matriz usando Es6 para la pregunta formulada:

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

suponer:

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

Primero verificaría si su implementación admite isArray:

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

También puedes intentar usar el instanceofoperador

v instanceof Array

jQuery también ofrece un $.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 es el más rápido entre todos los métodos (todos los navegadores compatibles):

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

Imagina que tienes esta matriz a continuación :

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

Javascript (navegadores nuevos y antiguos):

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

o

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

o

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

entonces llámalo así:

isArray(arr);

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

Array.isArray(arr);

jQuery:

$.isArray(arr);

Angular:

angular.isArray(arr);

Subrayar y Lodash:

_.isArray(arr);

Array.isArray funciona rápido, pero no es compatible con todas las versiones de navegadores. Por lo tanto, puede hacer una excepción para los demás y utilizar el método universal:

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

Función simple para verificar esto:

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

Como dice MDN aquí :

use Array.isArray u Object.prototype.toString.call para diferenciar objetos regulares de matrices

Me gusta esto:

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

• Array.isArray(arr)

Solo hay una solución de línea para esta pregunta

x instanceof Array

donde x es la variable, devolverá verdadero si x es una matriz y falso si no lo es.

Puede verificar el tipo de su variable si es una matriz con;

var myArray=[];

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

Haría una función para probar el tipo de objeto con el que está tratando ...

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

entonces puedes escribir una declaración if simple ...

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

Hago esto de una manera muy simple. Funciona para mi. ¿Algún inconveniente?

Array.prototype.isArray = true;

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

Este es mi intento de mejorar esta respuesta teniendo en cuenta los comentarios:

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

Elimina el if / else, y explica la posibilidad de que la matriz sea nula o indefinida

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

He actualizado el violín jsperf con dos métodos alternativos, así como la comprobación de errores.

Resulta que el método que define un valor constante en los prototipos 'Objeto' y 'Matriz' es más rápido que cualquiera de los otros métodos. Es un resultado algo sorprendente.

/* 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/>");

Estos dos métodos no funcionan si la variable toma el valor indefinido, pero funcionan si está seguro de que tienen un valor. Con respecto a la verificación teniendo en cuenta el rendimiento si un valor es una matriz o un valor único, el segundo método parece un método rápido válido. Es ligeramente más rápido que 'instanceof' en Chrome, dos veces más rápido que el segundo mejor método en Internet Explorer, Opera y Safari (en mi máquina).

Sé que la gente está buscando algún tipo de enfoque de JavaScript sin formato. Pero si quiere pensar menos, eche un vistazo aquí: http://underscorejs.org/#isArray

_.isArray(object) 

Devuelve verdadero si el objeto es una matriz.

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

La mejor solución que he visto es un reemplazo entre navegadores para typeof. Comprueba la solución de Angus Croll aquí .

La versión TL; DR está a continuación, pero el artículo es una gran discusión sobre el tema, por lo que debe leerlo si tiene tiempo.

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

Aquí está mi enfoque perezoso:

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

// ...

var test = [],
    wat = {};

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

Sé que es un sacrilegio "meterse" con el prototipo, pero parece funcionar significativamente mejor que el toStringmétodo recomendado .

Nota: Una trampa de este enfoque es que no funcionará más allá de los iframelímites , pero para mi caso de uso esto no es un problema.

Hay un buen ejemplo en el libro Patrones JavaScript de Stoyan Stefanov que supone manejar todos los problemas posibles y utilizar el método ECMAScript 5 Array.isArray () .

Asi que aqui esta:

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

Por cierto, si está usando jQuery, puede usar su método $ .isArray ()

La forma más fácil y rápida de verificar si un objeto es una matriz o no.

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

o

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

o puedes hacer una función de utilidad:

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

uso:

isArray(arr); //return true

Lo siguiente podría usarse si sabe que su objeto no tiene un método concat.

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

Podrías es el método de matriz, pero preferiría consultar con

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

Si los únicos dos tipos de valores que podrían pasarse a esta función son una cadena o una matriz de cadenas, manténgalo simple y use una typeofverificación para la posibilidad de la cadena:

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

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

En la búsqueda de la versión más corta, esto es lo que obtuve hasta ahora.

Tenga en cuenta que no existe una función perfecta que siempre detecte todas las combinaciones posibles. Es mejor conocer todas las habilidades y limitaciones de sus herramientas que esperar una herramienta 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))

Una función simple para probar si un valor de entrada es una matriz es la siguiente:

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

Esto funciona en varios navegadores y con navegadores más antiguos. Esto se extrae de la publicación del blog de TJ Crowders

Puedes probar esto:

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 función convertirá casi cualquier cosa en una 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]"
}

Utiliza algunas características más nuevas del navegador, por lo que es posible que desee rellenar esto para obtener el máximo soporte.

Ejemplos:

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

Las cadenas NB se convertirán en una matriz con un solo elemento en lugar de una matriz de caracteres. Elimine el isStringcheque si lo prefiere al revés.

Lo he usado Array.isArrayaquí porque es el más robusto y también el más simple.

En su caso, puede usar el concatmétodo de matriz que puede aceptar objetos individuales, así como matriz (e incluso combinados):

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 uno de los métodos más antiguos de Array (incluso IE 5.5 lo sabe bien).