JavaScript: compruebe si el objeto es una matriz

Introducción

Trabajar con matrices en JavaScript es una actividad común. A veces obtenemos una variable en JavaScript que necesitamos que sea una matriz, pero no estamos seguros de que lo sea.

Los tipos de datos no primitivos en JavaScripts son todos objetos (las funciones tienen su propio tipo, pero también son objetos). Como resultado, no es suficiente usar el typeof operador que se usa comúnmente para determinar un tipo de datos:

let result = { subject: 'Science', marks: 97 };
let numbers = [1, 2, 3, 4, 5];

console.log(typeof result); // Object
console.log(typeof numbers); // Object

En este artículo, veremos cómo verificar si una variable o valor dado es una matriz o no, en JavaScript.

Usando el método Array.isArray ()

Como sugiere el nombre, este método se puede utilizar para identificar si el argumento dado es una matriz o no. Devuelve un booleano (true/false) valor con el resultado.

Por ejemplo, con las siguientes variables el Array.isArray() El método determina correctamente si son uno o no:

let result = { subject: "Science", marks: 97 }; // Object
let numbers = [1, 2, 3, 4, 5]; // Array
let name = "Mark"; // String
let names = new Array("Jill", "Jane", "Jacqueline");

console.log(Array.isArray(result)); // false
console.log(Array.isArray(numbers)); // true
console.log(Array.isArray(name)); // false
console.log(Array.isArray(names)); // true

Usar la propiedad del constructor de un objeto

Cada objeto tiene un constructor propiedad (excepto los objetos creados con Object.create(null), una ocurrencia poco probable). Podemos comparar la propiedad del constructor directamente con las funciones del constructor de JavaScript. Por tanto, si lo comparamos con la función del constructor de matrices, sabremos si es una matriz.

Nota: Una función constructora es una función que inicializa un objeto. Si ha creado un objeto con la new palabra clave, lo hizo con una función constructora. Por ejemplo, en let myArray = new Array(1, 2) la función constructora utilizada es Array().

Puede usar la propiedad del constructor para determinar si una variable es una matriz:

let result = { subject: "Science", marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = "Mark";
let names = new Array("Jill", "Jane", "Jacqueline");

console.log(result.constructor === Array); // false
console.log(numbers.constructor === Array); // true
console.log(name.constructor === Array); // false
console.log(names.constructor === Array); // true

Usando la instancia de Operador

los instanceof El operador comprueba si se encuentra una función de constructor en la cadena de prototipos de un objeto. Si está menos familiarizado con la herencia prototípica de JavaScript, el operador verifica si un objeto fue creado por una clase y, si no, verifica si el objeto se derivó de esa clase.

Como el typeof operador, devuelve un valor booleano. Para determinar si una variable es una matriz, podemos usar instanceof Me gusta esto:

let result = { subject: "Science", marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = "Mark";
let names = new Array("Jill", "Jane", "Jacqueline");

console.log(result instanceof Array); // false
console.log(numbers instanceof Array); // true
console.log(name instanceof Array); // false
console.log(names instanceof Array); // true

Uso del método Object.prototype.call ()

Todos los objetos en JavaScript heredan propiedades del objeto prototipo principal, apropiadamente llamado Object.prototype. UN toString() El método existe en Object.prototype, por lo que cada objeto tiene un toString() método propio. los toString() método de Object.prototype muestra el tipo de objeto.

los call() método de objetos ejecuta una función pero cambia el valor de this al objeto pasado en sus argumentos, es decir, permite que un objeto utilice un método de otro objeto.

Por tanto, podemos utilizar Object.prototype.toString() para imprimir el tipo y luego usar call() así que está hecho para otro objeto. Luego comparamos ese valor de cadena para determinar si es una matriz:

let result = { subject: "Science", marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = "Mark";
let names = new Array("Jill", "Jane", "Jacqueline");

console.log(Object.prototype.toString.call(result)); // [object Object]
console.log(Object.prototype.toString.call(numbers)); // [object Array]
console.log(Object.prototype.toString.call(name)); // [object String]
console.log(Object.prototype.toString.call(names)); // [object Array]

console.log(Object.prototype.toString.call(result) === "[object Array]"); // false
console.log(Object.prototype.toString.call(numbers) === "[object Array]"); // true
console.log(Object.prototype.toString.call(name) === "[object Array]"); // false
console.log(Object.prototype.toString.call(names) === "[object Array]"); // true

Es poco probable que uses este método, ¡pero nunca está de más saber más sobre los objetos JavaScript!

Conclusión

En este artículo, analizamos algunas formas en JavaScript para determinar si un objeto es una matriz. El método más sencillo es el Array.isArray() método que probablemente se utilizará en la producción.

Sin embargo, siempre podemos aprovechar la instanceof operador y otras propiedades del objeto para determinar si es una matriz.