// 空 Map
const map1 = new Map()

// 从二维数组创建
const map2 = new Map([
  ['name', '张三'],
  ['age', 25],
])
console.log(map2) // Map {'name' => '张三', 'age' => 25}

// 从其他 Map 创建
const map3 = new Map(map2)

// 从 Object 创建
const obj = { a: 1, b: 2 }
const map4 = new Map(Object.entries(obj))

const map = new Map()

// 设置
map.set('name', '张三')
map.set(123, 'number key')
map.set(true, 'boolean key')
map.set({ id: 1 }, 'object key')
map.set(null, 'null key')
map.set(undefined, 'undefined key')

// 链式调用
map.set('a', 1).set('b', 2).set('c', 3)

// 获取
map.get('name') // '张三'
map.get(123) // 'number key'
map.get('notexist') // undefined

const map = new Map()

const key1 = { id: 1 }
const key2 = { id: 1 }

map.set(key1, 'value1')
map.set(key2, 'value2')

// 不同对象是不同的键
console.log(map.size) // 2
console.log(map.get(key1)) // 'value1'
console.log(map.get(key2)) // 'value2'
console.log(map.get({ id: 1 })) // undefined（新对象，不同引用）

const map = new Map([['name', '张三']])

// 判断存在
map.has('name') // true
map.has('age') // false

// 删除
map.delete('name') // true
map.delete('notexist') // false

// 清空
map.clear()
console.log(map.size) // 0

const map = new Map([
  ['name', '张三'],
  ['age', 25],
  ['city', '北京'],
])

// keys()
for (const key of map.keys()) {
  console.log(key) // 'name', 'age', 'city'
}

// values()
for (const value of map.values()) {
  console.log(value) // '张三', 25, '北京'
}

// entries()
for (const [key, value] of map.entries()) {
  console.log(key, value)
}

// forEach
map.forEach((value, key, map) => {
  console.log(key, value)
})

// for...of（默认使用 entries()）
for (const [key, value] of map) {
  console.log(key, value)
}

const map = new Map([
  ['a', 1],
  ['b', 2],
])

// Map 转数组
;[...map] // [['a', 1], ['b', 2]]
;[...map.keys()] // ['a', 'b']
;[...map.values()] // [1, 2]

// Map 转对象
Object.fromEntries(map) // { a: 1, b: 2 }

// 对象转 Map
const obj = { x: 1, y: 2 }
new Map(Object.entries(obj)) // Map {'x' => 1, 'y' => 2}

// Object 的键只能是字符串
const obj = {}
obj[1] = 'one'
obj['1'] = 'string one'
console.log(obj[1]) // 'string one'（被覆盖）

// Map 区分类型
const map = new Map()
map.set(1, 'one')
map.set('1', 'string one')
console.log(map.get(1)) // 'one'
console.log(map.get('1')) // 'string one'

const cache = new Map()

function memoize(fn) {
  return function (...args) {
    const key = JSON.stringify(args)
    if (cache.has(key)) {
      return cache.get(key)
    }
    const result = fn.apply(this, args)
    cache.set(key, result)
    return result
  }
}

const expensiveFn = memoize((n) => {
  console.log('Computing...')
  return n * n
})

expensiveFn(5) // 'Computing...' 25
expensiveFn(5) // 25（从缓存读取）

function countOccurrences(arr) {
  const counts = new Map()
  for (const item of arr) {
    counts.set(item, (counts.get(item) || 0) + 1)
  }
  return counts
}

const words = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
const counts = countOccurrences(words)
// Map {'apple' => 3, 'banana' => 2, 'cherry' => 1}

const elementData = new Map()

function setData(element, key, value) {
  if (!elementData.has(element)) {
    elementData.set(element, new Map())
  }
  elementData.get(element).set(key, value)
}

function getData(element, key) {
  return elementData.get(element)?.get(key)
}

const button = document.querySelector('button')
setData(button, 'clicks', 0)
setData(button, 'lastClick', null)

class BiMap {
  #forward = new Map()
  #reverse = new Map()

  set(key, value) {
    this.#forward.set(key, value)
    this.#reverse.set(value, key)
  }

  get(key) {
    return this.#forward.get(key)
  }

  getKey(value) {
    return this.#reverse.get(value)
  }

  delete(key) {
    const value = this.#forward.get(key)
    this.#forward.delete(key)
    this.#reverse.delete(value)
  }
}

const userIds = new BiMap()
userIds.set('user_001', '张三')
userIds.get('user_001') // '张三'
userIds.getKey('张三') // 'user_001'

const wm = new WeakMap()

const key = { id: 1 }
wm.set(key, 'value')

console.log(wm.get(key)) // 'value'
console.log(wm.has(key)) // true

wm.delete(key)
console.log(wm.has(key)) // false

// 不能使用原始值作为键
// wm.set('string', 'value'); // TypeError
// wm.set(1, 'value'); // TypeError

const privateData = new WeakMap()

class Person {
  constructor(name, age) {
    privateData.set(this, { name, age })
  }

  get name() {
    return privateData.get(this).name
  }

  get age() {
    return privateData.get(this).age
  }

  birthday() {
    privateData.get(this).age++
  }
}

const person = new Person('张三', 25)
console.log(person.name) // '张三'
console.log(person.age) // 25
person.birthday()
console.log(person.age) // 26

// 外部无法访问 privateData

const nodeData = new WeakMap()

function processNode(node) {
  if (nodeData.has(node)) {
    return nodeData.get(node)
  }

  const data = {
    processed: true,
    timestamp: Date.now(),
  }
  nodeData.set(node, data)
  return data
}

// 当 DOM 节点被移除时，关联数据自动被垃圾回收

const resultsCache = new WeakMap()

function heavyComputation(obj) {
  if (resultsCache.has(obj)) {
    console.log('From cache')
    return resultsCache.get(obj)
  }

  console.log('Computing...')
  const result = /* 复杂计算 */ Object.keys(obj).length
  resultsCache.set(obj, result)
  return result
}

const data = { a: 1, b: 2, c: 3 }
heavyComputation(data) // 'Computing...' 3
heavyComputation(data) // 'From cache' 3

// 当 data 不再被引用时，缓存自动清除

const listeners = new WeakMap()

function addListener(element, event, handler) {
  if (!listeners.has(element)) {
    listeners.set(element, new Map())
  }
  const elementListeners = listeners.get(element)

  if (!elementListeners.has(event)) {
    elementListeners.set(event, new Set())
  }
  elementListeners.get(event).add(handler)

  element.addEventListener(event, handler)
}

function removeAllListeners(element) {
  const elementListeners = listeners.get(element)
  if (!elementListeners) return

  for (const [event, handlers] of elementListeners) {
    for (const handler of handlers) {
      element.removeEventListener(event, handler)
    }
  }
  listeners.delete(element)
}