Aprende a implementar y depurar el método get en una hash table en JavaScript con seguridad y claridad. Verás cómo calcular la address a partir del key, recorrer el bucket correcto y devolver el value adecuado incluso cuando hay colisiones. Todo con ejemplos simples y código listo para usar.

¿Qué resuelve get en una hash table?

El método get permite recuperar el value asociado a un key. La idea central: el hash es determinista, por lo que un mismo key siempre genera la misma address. Con esa address accedemos al bucket (un array de arrays), donde cada elemento es una pareja [key, value].

• Hash determinista: mismo key, misma address.
• Buckets: listas internas donde pueden convivir varias parejas por colisión.
• Búsqueda puntual: se recorre solo el bucket objetivo, no toda la estructura.

Así, get ubica el bucket correcto y hace una búsqueda lineal hasta encontrar el key y devolver su value.

¿Cómo implementar get con manejo de colisiones en JavaScript?

La implementación se basa en cinco pasos: calcular la address, obtener el bucket, validar su existencia, recorrer con for y comparar el key en cada sublista. Si no hay coincidencia, se retorna undefined.

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

  hash(key) {
    // implementación existente del hash.
  }

  set(key, value) {
    // implementación existente del set.
  }

  get(key) {
    const address = this.hash(key);
    const currentBucket = this.data[address];

    if (currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          return currentBucket[i][1];
        }
      }
    }

    return undefined;
  }
}

• Calcula la address con this.hash(key).
• Toma el bucket con this.data[address].
• Si el bucket existe, recórrelo con un loop for.
• Compara currentBucket[i][0] === key en cada pareja [key, value].
• Devuelve currentBucket[i][1] al encontrar coincidencia.
• Si no hay coincidencia, retorna undefined.

¿Cómo recorre el loop for el bucket?

Cada bucket es una lista de listas. El índice i apunta a una sublista. En cada iteración se valida: si el elemento cero de esa sublista ([0]) es el key buscado, se regresa el elemento uno ([1]), que es el value. Si no, el loop continúa.

¿Qué retorna si el key no existe?

Si el bucket está vacío o no se encontró coincidencia durante el recorrido, la función regresa undefined. Esta señal es clara para indicar ausencia del elemento.

¿Cómo validar y probar con ejemplos usando set y get?

Primero, crea una instancia con un tamaño fijo para visualizar los buckets y posibles colisiones. Por ejemplo, 50 buckets para tener un espacio limitado y notar cuándo varios keys caen en la misma address.

fullscreen
const table = new HashTable(50);

table.set('Diego', 23);     // ejemplo ilustrativo.
table.set('Mariana', 98);   // puede colisionar con Diego.
table.set('Adriana', 2000); // otro par key-value.

console.log(table.get('Diego'));   // 23
console.log(table.get('Mariana')); // 98
console.log(table.get('Adriana')); // 2000
console.log(table.get('X'));       // undefined

• Si hay colisión, el bucket tendrá varias parejas [key, value] y el for localizará la correcta.
• La estructura interna luce así: [['Diego', 23], ['Mariana', 98]]. Cada sublista es una pareja.
• La búsqueda es lineal dentro del bucket, lo que simplifica el manejo de colisiones.

¿Qué retos siguen: delete y keys?

• Implementa delete(key): borra la pareja completa [key, value] al recibir un key.
• Implementa keys(): devuelve todos los keys existentes en la hash table.

Comparte tu solución en comentarios: será útil ver distintos enfoques para estas operaciones y cómo optimizas el recorrido por buckets.