JavaScript
Explica qué son los holes en arrays dispersos, cómo se diferencian de undefined y por qué cada método puede recorrerlos, omitirlos o densificarlos.
Un array disperso tiene una longitud que incluye posiciones donde no existe una propiedad de elemento.
const values = new Array(3);
values.length; // 3
Object.hasOwn(values, 0); // falseconst sparse = new Array(1);
const explicit = [undefined];sparse.length; // 1
explicit.length; // 1Pero:
Object.hasOwn(sparse, 0); // false
Object.hasOwn(explicit, 0); // trueAmbas lecturas devuelven undefined.
sparse[0]; // undefined
explicit[0]; // undefinedLa existencia de la propiedad es la diferencia.
const first = new Array(3);
const second = [1, , 3];Aumentar length:
const third = [1];
third.length = 3;Asignar un índice lejano:
const fourth = [];
fourth[5] = "A";Eliminar una posición:
const fifth = ["A", "B", "C"];
delete fifth[1];fifth.length; // 3
Object.hasOwn(fifth, 1); // falsePara retirar y cerrar el espacio utiliza splice o toSpliced.
const values = ["A", "B", "C"];
delete values[1];
values[2]; // "C"
values.length; // 3delete elimina una propiedad; no desplaza elementos.
values.splice(1, 1);
// ["A", "C"]Métodos basados en callbacks como estos normalmente no llaman el callback para posiciones vacías:
forEachmapfilterflatMapsomeeveryreducereduceRightconst sparse = new Array(3);
let calls = 0;
sparse.forEach(() => calls++);
calls; // 0const sparse = [1, , 3];
const mapped = sparse.map(
(value) => value * 2,
);mapped.length; // 3
Object.hasOwn(mapped, 1); // falseLa posición vacía continúa vacía.
const sparse = [1, , 3];
const filtered = sparse.filter(() => true);
filtered; // [1, 3]Solo incluye posiciones existentes que pasaron la condición.
El iterador de valores visita cada índice hasta length y produce undefined para holes.
const sparse = new Array(3);
[...sparse];
// [undefined, undefined, undefined]for (const value of sparse) {
console.log(value);
}Imprime undefined tres veces.
entries() también entrega pares para esas posiciones.
includes trata holes como undefined.
new Array(1).includes(undefined); // trueindexOf omite posiciones vacías.
new Array(1).indexOf(undefined); // -1find y findIndex visitan los índices y entregan undefined para posiciones vacías.
Estas diferencias hacen que los holes sean una fuente frecuente de sorpresa.
const values = [1, , 3];
1 in values; // false
Object.hasOwn(values, 1); // falsein también considera propiedades heredadas. Object.hasOwn pregunta únicamente por una propiedad propia.
const sparse = new Array(3);
const dense = Array.from(sparse);dense; // [undefined, undefined, undefined]
Object.hasOwn(dense, 0); // trueSpread produce un resultado similar.
En lugar de holes:
const zeros = Array.from(
{ length: 3 },
() => 0,
);const emptySlots = Array.from(
{ length: 3 },
() => null,
);Un valor explícito comunica mejor el estado que una propiedad ausente.
const rows = new Array(3).fill({ value: 0 });Esto densifica, pero utiliza la misma referencia en cada posición.
rows[0] === rows[1]; // truePara objetos independientes usa Array.from con una factory.
const values = ["A"];
values[-1] = "B";
values[1.5] = "C";
values["name"] = "D";Son propiedades normales del objeto array.
values.length; // 1
Object.keys(values);
// ["0", "-1", "1.5", "name"]Los métodos de array basados en longitud normalmente no las recorren como elementos.
length está restringida al rango de longitud de arrays. Asignaciones inválidas pueden lanzar RangeError.
No uses arrays como mapas dispersos de IDs enormes.
items[customerId] = customer;Si las claves no son posiciones compactas, un objeto o Map comunica mejor el modelo y evita una longitud engañosa.
Los motores optimizan arrays densos y pueden representar arrays dispersos de otra manera.
No dependas de una complejidad concreta para todas las implementaciones, pero evita holes accidentales cuando buscas una lista ordinaria:
Menos claro:
const slots = new Array(5);
slots[2] = reservation;Más explícito:
const slots = Array.from(
{ length: 5 },
() => null,
);
slots[2] = reservation;null comunica una posición existente sin reserva.
undefined.delete para retirar un elemento de una lista.new Array(length).map(...).fill({}).length.undefined, pero no existe como elemento.delete crea holes y no cambia length.map y forEach omiten holes.for...of, spread e includes los tratan como undefined.filter y Array.from pueden producir arrays densos.null suelen comunicar mejor una ausencia intencional.Map.¿Qué diferencias hay entre estos resultados?
const sparse = new Array(1);
sparse.includes(undefined);
sparse.indexOf(undefined);includes devuelve true porque trata el hole como undefined; indexOf devuelve -1 porque omite posiciones vacías.
Map presenta una colección clave-valor donde las claves conservan su identidad y pueden ser de cualquier tipo.