const hash = (key, size) => {
  let total = 0;
 
  for (const char of String(key)) {
    // 글자를 코드값으로 바꿔 더한다
    total += char.charCodeAt(0);
  }
 
  // 배열 크기로 나눈 나머지를 쓰면 항상 0 ~ size-1 안에 들어온다
  return total % size;
};
 
console.log(hash('name', 10)); // 7
console.log(hash('name', 10)); // 7  같은 키는 항상 같은 자리
console.log(hash('age', 10)); // 1

hash('name', 10); // 7
hash('user', 10); // 7   같은 칸
hash('age', 10); // 1
hash('city', 10); // 1   같은 칸

class HashTable {
  constructor(size = 10) {
    // 각 칸에 { key, value } 들이 담긴다
    this.buckets = new Array(size);
  }
 
  hash(key) {
    let total = 0;
 
    for (const char of String(key)) {
      total += char.charCodeAt(0);
    }
 
    return total % this.buckets.length;
  }
 
  set(key, value) {
    // 1단계: 어느 칸에 넣을지 계산한다
    const index = this.hash(key);
 
    // 그 칸을 처음 쓰는 경우에만 배열을 만든다
    if (!this.buckets[index]) {
      this.buckets[index] = [];
    }
 
    const bucket = this.buckets[index];
 
    // 2단계: 그 칸에 같은 키가 이미 있는지 확인한다.
    // 다른 키가 충돌해서 같이 들어 있을 수 있으므로 키를 직접 비교해야 한다
    const entry = bucket.find(item => item.key === key);
 
    if (entry) {
      // find 는 칸 안에 들어 있는 객체를 그대로 돌려준다.
      // 따라서 여기서 값을 바꾸면 칸 안의 값이 바뀐다
      entry.value = value;
    } else {
      bucket.push({ key, value });
    }
  }
 
  get(key) {
    // 1단계: 넣을 때와 같은 계산을 하므로 훑지 않고 바로 그 칸으로 간다
    const bucket = this.buckets[this.hash(key)];
 
    // 그 칸을 한 번도 쓴 적이 없으면 찾는 키도 없다
    if (!bucket) {
      return undefined;
    }
 
    // 2단계: 칸 안에 여러 개가 있을 수 있으니 키가 맞는 것을 고른다
    const entry = bucket.find(item => item.key === key);
 
    // 칸은 있는데 그 키가 없을 수도 있다
    return entry?.value;
  }
}
 
const table = new HashTable();
 
table.set('name', 'ycow');
table.set('user', 'admin'); // name 과 같은 7번 칸으로 간다
 
console.log(table.get('name')); // ycow
console.log(table.get('user')); // admin
console.log(table.get('none')); // undefined
 
// 7번 칸에 두 개가 나란히 들어 있다
console.log(table.buckets[7]);
// [ { key: 'name', value: 'ycow' }, { key: 'user', value: 'admin' } ]

class OpenAddressing {
  constructor(size = 10) {
    // 칸마다 { key, value } 하나씩만 들어간다
    this.slots = new Array(size);
  }
 
  hash(key) {
    let total = 0;
 
    for (const char of String(key)) {
      total += char.charCodeAt(0);
    }
 
    return total % this.slots.length;
  }
 
  // 이 키가 있어야 할 자리를 찾는다.
  // 빈 칸이거나 같은 키를 만나면 거기가 제자리다
  findSlot(key) {
    let index = this.hash(key);
 
    for (let i = 0; i < this.slots.length; i++) {
      const slot = this.slots[index];
 
      if (!slot || slot.key === key) {
        return index;
      }
 
      // 다른 키가 차지하고 있으면 한 칸 뒤로. 끝에 닿으면 처음으로 돌아온다
      index = (index + 1) % this.slots.length;
    }
 
    return -1; // 한 바퀴 다 돌았는데 자리가 없다
  }
 
  set(key, value) {
    const index = this.findSlot(key);
 
    if (index === -1) {
      throw new Error('가득 참');
    }
 
    this.slots[index] = { key, value };
  }
 
  get(key) {
    const index = this.findSlot(key);
 
    return index === -1 ? undefined : this.slots[index]?.value;
  }
}
 
const table = new OpenAddressing();
 
table.set('name', 'ycow'); // 7번 칸
table.set('user', 'admin'); // 7번이 차 있으니 8번으로
 
console.log(table.get('name')); // ycow
console.log(table.get('user')); // admin

table.slots[7] = undefined; // name 을 지운다고 그냥 비우면
 
console.log(table.get('user')); // undefined  <- 못 찾는다

const obj = {};
 
obj[1] = 'number 1';
obj['1'] = 'string 1';
 
console.log(obj); // { '1': 'string 1' }
console.log(Object.keys(obj).length); // 1  키가 하나로 합쳐졌다
 
const map = new Map();
 
map.set(1, 'number 1');
map.set('1', 'string 1');
 
console.log(map.size); // 2  타입을 그대로 구분한다

const obj = { b: 1, 2: 1, a: 1, 1: 1 };
 
console.log(Object.keys(obj)); // ['1', '2', 'b', 'a']
 
const map = new Map([['b', 1], [2, 1], ['a', 1], [1, 1]]);
 
console.log([...map.keys()]); // ['b', 2, 'a', 1]