Introducci贸n
Contenido
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.