Construye y entiende una hash table en JavaScript desde cero con un enfoque práctico. Verás cómo inicializar la estructura, cómo funciona una hash function creada para la demo y cómo implementar el método set para agregar pares key–value sin perder datos cuando hay colisiones.

¿Qué estructura creamos y cómo se inicializa en JavaScript?

Una hash table es, en esencia, un objeto que usa una hash function para convertir una key en una dirección (address) dentro de un array de tamaño fijo llamado buckets. En el ejemplo, se instancia con 50 buckets para guardar información de forma eficiente.

• Se trabaja en DevTools en la sección de console para probar el código.
• La clase tiene un constructor que recibe un size y crea un array con ese tamaño.
• La hash function usada es arbitraria, pensada solo para la demostración. Se comenta que genera un número aleatorio del 0 al 65535 y se asocia a UTF-16. Su objetivo: devolver un hash que actúe como address donde guardar el valor.
• No necesitas implementar tu propia hash function en producción: hay opciones open source en GitHub.

¿Cómo luce la clase base con constructor y hash function?

fullscreen
class HashTable {
  constructor(size) {
    this.data = new Array(size); // 50 buckets en el ejemplo.
  }

  hashMethod(key) {
    // Método arbitrario para la demo: retorna una dirección válida.
    // Implementación real no es relevante aquí.
    return Math.floor(Math.random() * this.data.length);
  }
}

¿Cómo agregar elementos con set y evitar colisiones en buckets?

El primer método esencial es set. Recibe dos parámetros: key y value. Convierte la key en un address usando la hash function, y guarda el par key–value en el bucket correspondiente. Si ya existe información en ese address, ocurre una colisión y se agrega un nuevo par sin sobrescribir lo anterior.

• Se calcula address con this.hashMethod(key).
• Si no existe this.data[address], se crea un nuevo array para ese bucket.
• Si ya existe, se agrega otro [key, value] al mismo bucket.
• Se retorna this.data para inspeccionar lo guardado en memoria.

¿Cuál es la lógica exacta del método set?

fullscreen
class HashTable {
  constructor(size) {
    this.data = new Array(size);
  }

  hashMethod(key) {
    // Demo: devuelve una dirección válida.
    return Math.floor(Math.random() * this.data.length);
  }

  set(key, value) {
    const address = this.hashMethod(key);
    if (!this.data[address]) {
      this.data[address] = [];
    }
    this.data[address].push([key, value]);
    return this.data; // Para ver cómo se guarda en memoria.
  }
}

• Colisiones: dos o más pares key–value en un mismo bucket.
• Objetivo en colisiones: no sobrescribir datos previos, solo agregar el nuevo par.
• Beneficio: se preserva la información y luego se podrá acceder al valor correcto con el método get.

¿Cómo probar en consola y qué observar al insertar datos?

Con 50 buckets, al insertar elementos se verá cómo se ocupan direcciones de forma aleatoria y, a veces, se producen colisiones en un mismo address.

¿Qué pasos seguir para ver el comportamiento en DevTools?

fullscreen
const myHashTable = new HashTable(50);

myHashTable.set('Diego', 1990);
myHashTable.set('Mariana', 98);
myHashTable.set('Alejandra', 2000);

• Al crear la instancia se obtiene un array con 50 espacios disponibles.
• Al hacer set('Diego', 1990) se ocupa un bucket, por ejemplo, en un índice como 11.
• Al hacer set('Mariana', 98) puede ocurrir colisión y verse dos pares en el mismo índice.
• Al agregar set('Alejandra', 2000) se usa otro bucket libre, reduciendo el total de espacios disponibles.

En la siguiente implementación se trabajará el método get: al pasar una key, debe regresar su value incluso cuando hubo colisiones en el bucket correspondiente.

¿Tienes dudas sobre el manejo de colisiones o la inicialización de buckets? Comenta tu escenario y lo revisamos juntos.