CHEEMS的小窝

1
const curry = (func, ...args) => {
2
  return args.length >= func.length ? func(...args) : (...rest) => curry(func, ...args, ...rest)
3
}

1
const debounce = (func, t, options = { immediate: false }) => {
2
  const { immediate } = options
3
  let timer = null
4

5
  const debounced = function (...args) {
6
    if (timer !== null) clearTimeout(timer)
7
    if (immediate) {
8
      if (timer === null) {
9
        func.apply(this, args)
10
      }
11
      timer = setTimeout(() => {
12
        timer = null
13
      }, t)
14
    } else {
15
      timer = setTimeout(() => {
16
        func.apply(this, args)
17
        timer = null
18
      }, t)
19
    }
20
  }
21

22
  debounced.cancel = () => {
23
    if (timer !== null) {
24
      clearTimeout(timer)
25
      timer = null
26
    }
27
  }
28

29
  return debounced
30
}

1
const throttle = (func, t, options = { immediate: false }) => {
2
  const { immediate } = options
3
  let timer = null
4

5
  const throttled = function (...args) {
6
    if (timer !== null) return
7
    if (immediate) {
8
      func.apply(this, args)
9
      timer = setTimeout(() => {
10
        timer = null
11
      }, t)
12
    } else {
13
      timer = setTimeout(() => {
14
        func.apply(this, args)
15
        timer = null
16
      }, t)
17
    }
18
  }
19

20
  throttled.cancel = () => {
21
    if (timer !== null) {
22
      clearTimeout(timer)
23
      timer = null
24
    }
25
  }
26

27
  return throttled
28
}

1
const deepClone = (target, weakMap = new WeakMap()) => {
2
  if (typeof target !== 'object' || target === null) return target
3
  if (weakMap.has(target)) return weakMap.get(target)
4
  const res = Array.isArray(target) ? [] : {}
5
  weakMap.set(target, res)
6
  for (const key in target) {
7
    if (target.hasOwnProperty(key)) {
8
      res[key] = deepClone(target[key], weakMap)
9
    }
10
  }
11
  return res
12
}

1
const PromiseAll = (promises) => {
2
  let count = 0
3
  const res = []
4
  return new Promise((resolve, reject) => {
5
    promises.forEach((p, i) => {
6
      Promise.resolve(p).then((result) => {
7
        res[i] = result
8
        count++
9
        if (count === promises.length) resolve(res)
10
      }, reject)
11
    })
12
  })
13
}

1
const PromiseRace = (promises) => {
2
  return new Promise((resolve, reject) => {
3
    promises.forEach((p) => {
4
      Promise.resolve(p).then(resolve, reject)
5
    })
6
  })
7
}

1
Function.prototype.myApply = function (ctx, args) {
2
  ctx = ctx || globalThis
3
  const key = Symbol()
4
  ctx[key] = this
5
  const res = ctx[key](...(args || []))
6
  delete ctx[key]
7
  return res
8
}

1
Function.prototype.myCall = function (ctx, ...args) {
2
  ctx = ctx || globalThis
3
  const key = Symbol()
4
  ctx[key] = this
5
  const res = ctx[key](...(args || []))
6
  delete ctx[key]
7
  return res
8
}

1
Function.prototype.myBind = function (ctx, ...args) {
2
  ctx = ctx || globalThis
3
  return (...callArgs) => this.myCall(ctx, ...args, ...callArgs)
4
}

1
const flatten_recur = (arr) => {
2
  let res = []
3
  for (const item of arr) {
4
    if (Array.isArray(item)) {
5
      res = res.concat(flatten_recur(item))
6
    } else {
7
      res.push(item)
8
    }
9
  }
10
  return res
11
}

1
const flatten_stack = (arr) => {
2
  const stack = [...arr]
3
  const res = []
4
  while (stack.length) {
5
    const item = stack.pop()
6
    if (Array.isArray(item)) {
7
      stack.push(...item)
8
    } else {
9
      res.push(item)
10
    }
11
  }
12
  return res.reverse()
13
}

1
const flatten_reduce = (arr) => {
2
  return arr.reduce((prev, cur) => {
3
    return prev.concat(Array.isArray(cur) ? flatten_reduce(cur) : cur)
4
  }, [])
5
}

1
arr.filter((item, index) => arr.indexOf(item) === index)

1
const myNew = (Constructor, ...args) => {
2
  if (typeof Constructor !== 'function') {
3
    throw new TypeError('构造器必须为函数')
4
  }
5
  const obj = Object.create(Constructor.prototype)
6
  const res = Constructor.apply(obj, args)
7
  // ECMA规定如果构造函数返回对象则new也返回这个对象，如果返回基本类型则忽略
8
  return typeof res === 'object' && res !== null ? res : obj
9
}

1
const compareVersions = (v1, v2) => {
2
  v1 = v1.split('.')
3
  v2 = v2.split('.')
4
  const maxLen = Math.max(v1.length, v2.length)
5
  for (let i = 0; i < maxLen; i++) {
6
    const num1 = parseInt(v1[i] || '0', 10)
7
    const num2 = parseInt(v2[i] || '0', 10)
8
    if (num1 > num2) return 1
9
    if (num1 < num2) return -1
10
  }
11
  return 0
12
}

1
class EventBus {
2
  constructor() {
3
    this.event = {}
4
  }
5
  on(key, func) {
6
    if (!this.event[key]) this.event[key] = []
7
    this.event[key].push(func)
8
    return this
9
  }
10
  emit(key, ...args) {
11
    if (!this.event[key]) return
12
    this.event[key].forEach((func) => func(...args))
13
    return this
14
  }
15
  off(key, func) {
16
    if (!this.event[key]) return
17
    this.event[key] = this.event[key].filter((f) => f !== func)
18
    return this
19
  }
20
  once(key, func) {
21
    const wrapper = (...args) => {
22
      func(...args)
23
      this.off(key, wrapper)
24
    }
25
    this.on(key, wrapper)
26
    return this
27
  }
28
  clear(key) {
29
    key ? delete this.event[key] : (this.event = {})
30
    return this
31
  }
32
}

1
class UndoRedo {
2
  constructor(maxSize = 50) {
3
    this.undoStack = []
4
    this.redoStack = []
5
    this.maxSize = maxSize
6
    this.cur = null
7
  }
8
  execute(x) {
9
    if (this.undoStack.length >= this.maxSize) {
10
      this.undoStack.shift() // 超出容量弹出最早的
11
    }
12
    if (this.cur !== null) this.undoStack.push(this.cur)
13
    this.cur = x
14
    this.redoStack = [] // 新操作要清空redo
15
  }
16
  undo() {
17
    if (!this.undoStack.length) return
18
    this.redoStack.push(this.cur)
19
    this.cur = this.undoStack.pop()
20
  }
21
  redo() {
22
    if (!this.redoStack.length) return
23
    this.undoStack.push(this.cur)
24
    this.cur = this.redoStack.pop()
25
  }
26
}

1
class LRUCache {
2
  constructor(maxSize) {
3
    this.maxSize = maxSize
4
    this.map = new Map()
5
  }
6
  get(key) {
7
    if (!this.map.has(key)) return -1
8
    const value = this.map.get(key)
9
    this.map.delete(key)
10
    this.map.set(key, value)
11
    return value
12
  }
13
  set(key, value) {
14
    if (this.map.has(key)) {
15
      this.map.delete(key)
16
    }
17
    if (this.map.size >= this.maxSize) {
18
      const firstKey = this.map.keys().next().value
19
      this.map.delete(firstKey)
20
    }
21
    this.map.set(key, value)
22
  }
23
}

1
class Node {
2
  constructor(key, value) {
3
    this.key = key
4
    this.value = value
5
    this.prev = null
6
    this.next = null
7
  }
8
}
9

10
class LRUCache {
11
  constructor(maxSize) {
12
    this.maxSize = maxSize
13
    this.map = new Map()
14
    this.head = new Node(null, null) // 虚拟头节点，方便操作
15
    this.tail = new Node(null, null) // 虚拟尾节点，方便操作
16
    this.head.next = this.tail
17
    this.tail.prev = this.head
18
  }
19
  _delete(node) {
20
    node.prev.next = node.next
21
    node.next.prev = node.prev
22
  }
23
  _insertToHead(node) {
24
    node.next = this.head.next
25
    node.prev = this.head
26
    this.head.next.prev = node
27
    this.head.next = node
28
  }
29
  get(key) {
30
    if (!this.map.has(key)) return -1
31
    const node = this.map.get(key)
32
    this._delete(node)
33
    this._insertToHead(node)
34
    return node.value
35
  }
36
  set(key, value) {
37
    if (this.map.has(key)) {
38
      this._delete(this.map.get(key))
39
      this.map.delete(key)
40
    }
41
    if (this.map.size >= this.maxSize) {
42
      const tailNode = this.tail.prev // 最旧的尾部节点
43
      this._delete(tailNode)
44
      this.map.delete(tailNode.key)
45
    }
46
    const node = new Node(key, value)
47
    this._insertToHead(node)
48
    this.map.set(key, node)
49
  }
50
}