objetos - recorrer objeto json javascript




Comprobar si el objeto es una matriz? (20)

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 .


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.


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

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

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

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

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


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)

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
}

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


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

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

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

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



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

var myArray=[];

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

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

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


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.


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.


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)

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.





arrays