JavaScript: compruebe si el objeto es una matriz

En este artículo, discutiremos varios métodos para determinar si un objeto es una matriz en JavaScript utilizando el método Arrays.isArray(), el operador instanceof, etc.

Introducción

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

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

1
2
3
4
5
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 determinado es una matriz o no, en JavaScript.

Usando el método Array.isArray()

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

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

1
2
3
4
5
6
7
8
9
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

Uso de la propiedad constructor de un objeto

Cada objeto tiene una propiedad constructor (excepto los objetos creados con Object.create(null), algo poco probable). Podemos comparar la propiedad constructora directamente con las funciones constructoras de JavaScript. Por tanto, si la comparamos con la función constructora de arrays, sabremos si es un array.

Nota: Una función constructora es una función que inicializa un objeto. Si ha creado un objeto con la palabra clave nuevo, 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:

1
2
3
4
5
6
7
8
9
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

Uso del operador instanceof

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

Al igual que el operador typeof, devuelve un valor booleano. Para determinar si una variable es una matriz, podemos usar instanceof como este:

1
2
3
4
5
6
7
8
9
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, acertadamente llamado Object.prototype. Existe un método toString() en Object.prototype, por lo que cada objeto tiene un método toString() propio. El método toString() de Object.prototype muestra el tipo de un objeto.

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

Por lo tanto, podemos usar Object.prototype.toString() para imprimir el tipo y luego usar call() para que se haga para otro objeto. Luego comparamos ese valor de cadena para determinar si es una matriz:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
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 utilice este método, ¡pero nunca está de más saber más sobre los objetos de 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 fácil es el método Array.isArray() que probablemente se usará en producción.

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