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.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *