matriz - recorrer array de objetos javascript

Comprobar si el objeto es una matriz?

Question

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. Entonces puedo pasarlo por alto 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 .

Answer 1

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 tener un rendimiento significativamente mejor que el método recomendado para la toString .

Nota: un inconveniente de este enfoque es que no funcionará a través de los límites de iframe , pero para mi caso de uso esto no es un problema.

Answer 2

Array.isArray funciona rápido, pero no es compatible con todas las versiones de los navegadores. Entonces podrías hacer una excepción para otros y usar el método universal:

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

Answer 3

Como dice MDN aquí :

use Array.isArray o Object.prototype.toString.call para diferenciar los objetos regulares de las matrices

Me gusta esto:

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

• Array.isArray(arr)

Answer 4

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

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

O puedes usar typeof para probar si es una cadena:

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

O si no estás preocupado por el rendimiento, puedes hacer un acuerdo con 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 completo del blog de @TJ Crowder , como se publicó en su comentario a continuación.

Echa un vistazo a este jsben.ch/#/QgYAV de jsben.ch/#/QgYAV para obtener una idea de qué método funciona mejor: jsben.ch/#/QgYAV

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

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

Answer 5

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 el guión bajo, puede usar _.isArray(obj)

Si no necesita detectar matrices creadas en diferentes marcos, también puede usar instanceof

obj instanceof Array

Answer 6

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 funciones más nuevas del navegador, por lo que es posible que desee realizar un relleno múltiple 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 la verificación isString si lo prefiere al revés.

He usado Array.isArray aquí porque es el más robusto y también el más simple.

Answer 7

Este es el más rápido entre todos los métodos (todos los navegadores son compatibles):

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

Answer 8

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

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

Se deshace de if / else y da cuenta de la posibilidad de que la matriz sea nula o indefinida

Answer 9

Función simple para comprobar esto:

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

Answer 10

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)

Answer 11

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 simple declaración if ...

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

Answer 12

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

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á utilizando jQuery, puede usar el método $.isArray()

Answer 13

He actualizado el fiddle 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 ''Array'' 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 sí funcionan si está seguro de que tienen un valor. Con respecto a verificar con el rendimiento en mente si un valor es una matriz o un valor único, el segundo método parece ser 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).

Answer 14

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

Subrayado y Lodash:

_.isArray(arr);

Answer 15

La forma más fácil y rápida de comprobar 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

Answer 16

La mejor solución que he visto es un reemplazo de navegador cruzado para typeof. Verifique la solución de Angus Croll here .

La versión de TL; DR está más abajo, pero el artículo es una gran discusión sobre el problema, por lo que debería 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 */};

Answer 17

Podrías usar el método isArray pero preferiría consultar con

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

Answer 18

Primero comprobaría si su implementación soporta isArray :

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

También puedes intentar usar el operador instanceof

v instanceof Array

Answer 19

Puede probar este enfoque: http://web.archive.org/web/20100424091244/http://www.ajaxdr.com/code/javascript-version-of-phps-is_array-function/

EDITAR : también, si ya está utilizando JQuery en su proyecto, puede usar su función $.isArray() .

Answer 20

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

var myArray=[];

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

Answer 21

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

Answer 22

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

_.isArray(object) 

Devuelve true si el objeto es un Array.

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

Answer 23

Se puede usar lo siguiente si sabe que su objeto no tiene un método concat.

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

Answer 24

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

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

Answer 25

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.

Answer 26

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 es extraído de la publicación del blog de TJ Crowders.

Answer 27

jQuery también ofrece un $.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>

Answer 28

Array.isArray

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

Answer 29

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

En busca de la versión más corta aquí es lo que tengo hasta ahora.

Tenga en cuenta que no hay una función perfecta que siempre detectará todas las combinaciones posibles. Es mejor conocer todas las capacidades y limitaciones de sus herramientas que esperar una herramienta mágica.

Answer 30

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))