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 *