[javascript] Comprobar si el objeto es una matriz


14 Answers

El método proporcionado 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 puede usar typeof para probar si se trata de un String:

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

O si no le preocupa el rendimiento, puede hacer una concat a una nueva matriz vacía.

someVar = [].concat( someVar );

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

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

Vea un tratamiento completo del blog de @TJ Crowder , tal como se publicó en su comentario a continuación.

Vea este jsben.ch/#/QgYAV de jsben.ch/#/QgYAV para tener una idea de qué método funciona mejor: jsben.ch/#/QgYAV

Desde @Bharath convert string a array 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']
Question

Intento escribir una función que acepte una lista de cadenas o una sola cadena. Si es una cadena, entonces quiero convertirla a una matriz con solo un elemento. Entonces puedo recorrerlo sin temor a un error.

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

He redondeado las diversas soluciones a continuación y he creado una prueba jsperf .




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 con el navegador cruzado y con navegadores más antiguos. Esto se extrae de la publicación de blog de TJ Crowders




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.




En los navegadores modernos puedes hacer

Array.isArray(obj)

( developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… 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 subrayado, puede usar _.isArray(obj)

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

obj instanceof Array



var is_array = function (value) {
   return value &&
     typeof value === 'object' &&
     typeof value.length === 'number' &&
     typeof value.splice === 'function' &&
    !(value.propertyIsEnumerable('length'));
};

Esta función ha sido tomada del libro "JS the good parts", funciona perfecto para mí.




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

En la búsqueda de la versión más corta aquí está 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 tus herramientas que esperar una herramienta mágica.




Función simple para verificar esto:

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



Array.isArray funciona rápido, pero no es compatible con todas las versiones de navegadores. Entonces puedes 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]';
        }



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 toString recomendado .

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




Haría una función para probar el tipo de objeto con el que estás 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
}



Lo sé, la gente está buscando algún tipo de enfoque de JavaScript sin procesar. Pero si quieres pensar menos, echa 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



Como dice MDN aquí :

utilice Array.isArray u Object.prototype.toString.call para diferenciar los objetos normales de las matrices

Me gusta esto:

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

  • Array.isArray(arr)




Array.isArray

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



Si los dos únicos tipos de valores que se pueden pasar a esta función son una cadena o una matriz de cadenas, manténgala simple y use un tipo de verificación para la posibilidad de cadena:

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



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 puede hacer una función de utilidad:

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

uso:

isArray(arr); //return true



Related