Métodos Estáticos del Constructor Array

javascript

4 Minutos

16 may 2025

🏭 Métodos del Constructor `Array`

Además de los métodos que llamamos en las instancias de arreglos (como miArreglo.push(), miArreglo.slice()), el propio constructor Array tiene métodos útiles adjuntos directamente a él. A estos los llamamos métodos estáticos.

1. `Array.isArray(valor)`: Verificando si es un Arreglo

Este método es la forma más confiable para determinar si un valor dado es realmente un arreglo.

let lista = [1, 2, 3];
let texto = "Hola";
let objeto = { a: 1 };
let nada = null;

console.log(Array.isArray(lista)); // Muestra true
console.log(Array.isArray(texto)); // Muestra false
console.log(Array.isArray(objeto)); // Muestra false
console.log(Array.isArray(nada)); // Muestra false
console.log(Array.isArray(new Array())); // Muestra true

AVISO

⚠️ ¿Por qué no usar instanceof Array? Puede fallar en ciertos escenarios con múltiples contextos de JavaScript (como iframes o web workers). Array.isArray() es siempre seguro.

2. `Array.from(iterable[, mapFn[, thisArg]])`: Creando Arreglos desde Iterables

Ya vimos Array.from() brevemente al hablar de copias. Su función principal es crear una nueva instancia de Array a partir de:

a) Objetos iterables: Como strings, Set, Map, NodeList. b) Objetos similares a arreglos (array-like): Objetos que tienen una propiedad length y elementos indexados (como el objeto arguments en funciones no-flecha).

// Desde un string
let letras = Array.from("ABC");
console.log(letras); // Muestra ['A', 'B', 'C']

// Desde un Set
let miSet = new Set(["Uno", "Dos", "Uno"]);
let setArray = Array.from(miSet);
console.log(setArray); // Muestra ["Uno", "Dos"]

// Desde una NodeList (ejemplo conceptual)
// let parrafos = document.querySelectorAll('p');
// let parrafosArray = Array.from(parrafos);

// Desde un objeto array-like
function mostrarArgumentos() {
  let argsArray = Array.from(arguments); // 'arguments' es array-like
  console.log(argsArray);
}
mostrarArgumentos(10, "X", true); // Muestra [10, "X", true]

`Array.from()` con Función de Mapeo

Opcionalmente, Array.from() puede aceptar una función de mapeo como segundo argumento. Esta función se llama para cada elemento del iterable mientras se crea el nuevo arreglo. Es como hacer Array.from(iterable).map(mapFn), pero más eficiente.

// Crear un arreglo con números del 1 al 5
let rango = Array.from({ length: 5 }, (valorNoUsado, indice) => indice + 1);
// {length: 5} es un objeto array-like
// La función map recibe (elemento, indice)
console.log(rango); // Muestra [1, 2, 3, 4, 5]

// Crear un arreglo con los cuadrados de otro
let numerosBase = [1, 2, 3, 4];
let cuadrados = Array.from(numerosBase, (num) => num * num);
console.log(cuadrados); // Muestra [1, 4, 9, 16]

INFO

💡 Array.from() es muy útil para convertir colecciones que no son arreglos (pero se parecen o son iterables) en arreglos reales para poder usar métodos como forEach, map, filter, etc.

3. `Array.of(...elementos)`: Creando Arreglos con Argumentos

El método Array.of() crea una nueva instancia de Array con un número variable de argumentos, sin importar el número o tipo de los argumentos.

¿Por qué existe? Principalmente para solucionar la confusión del constructor new Array() cuando se le pasa un solo número.

// Con new Array()
let arr1 = new Array(2); // Crea un arreglo con 2 empty slots: [ , ]
let arr2 = new Array(1, 2); // Crea [1, 2]

// Con Array.of()
let arrOf1 = Array.of(2); // Crea [2]
let arrOf2 = Array.of(1, 2); // Crea [1, 2]
let arrOf3 = Array.of("a", true, null); // Crea ["a", true, null]
let arrOf4 = Array.of(); // Crea []

Array.of(x) siempre crea un arreglo con x como su único elemento, a diferencia de new Array(x) que crea un arreglo vacío de longitud x.

☝️🤓

🏋️‍♂️ Ejercicio

Escribe una función llamada filtrarSoloArreglos que reciba un arreglo con valores mixtos y devuelva un nuevo arreglo conteniendo únicamente los elementos que eran arreglos en la entrada. Usa Array.isArray().

Ejemplo: filtrarSoloArreglos([1, [2, 3], "a", [], {b:1}, [4]]) debería devolver [[2, 3], [], [4]].

🏋️‍♂️ Ejercicio

Usa Array.from() para:

Crear un arreglo chars a partir del string "JavaScript".
Crear un arreglo dobles a partir de [5, 10, 15], donde cada número del nuevo arreglo sea el doble del original (usa la función de mapeo).
Crear un arreglo indices de longitud 3 que contenga los índices [0, 1, 2] (usa un objeto {length: 3} y la función de mapeo).

Muestra los tres arreglos resultantes.

🚀 Extra

Investiga sobre: 1. ¿Qué otros métodos estáticos tiene el constructor Array (quizás menos comunes)? 2. ¿Cómo funciona exactamente un “objeto similar a arreglo” (array-like object)? ¿Qué propiedades debe tener para que Array.from() funcione con él? 3. Compara Array.of(1, 2, 3) con [1, 2, 3] y new Array(1, 2, 3). ¿Hay alguna diferencia en el resultado o el rendimiento?