面试题
1. 写一个 LRU 缓存函数
LRU(Least Recently Used)算法。该算法的观点是，最近被访问的数据那么它将来访问的概率就大，缓存满的时候，优先淘汰最无人问津者。 算法实现思路：基于一个双链表的数据结构，在没有满员的情况下，新来的k-v放在链表的头部，以后每次获取缓存中的k-v时就将该k-v移到最前面，缓存满的时候优先淘汰末尾的。 双向链表的特点，具有头尾指针，每个节点都有prev（前驱）和next（后继）指针分别指向他的前一个和后一个节点。 关键点：在双链表的插入过程中要注意顺序问题，一定是在保持链表不断的情况下先处理指针，最后才将源头指针指向新插入的元素，在代码实现中请注意看注释中说明的顺序注意点。
class lruCache {
constructor(limit) {
this.limit = limit || 10
// head指针指向表头元素，即为最常用的元素
this.head = this.tail = undefined
this.map = {}
this.size = 0
}
get(key, IfreturnNode){
let node = this.map[key]
// 如果查找不到含有'key'这个属性的缓存对象
if (node === undefined) return
// 如果查找到的缓存对象已经是tail（最近使用过的）
if (node === this.head) { // 判断该节点是不是第一个节点
// 是的话，不用移动元素，直接返回
return IfreturnNode? node: node.value
}
// 不是头节点，铁定要移动元素了
if (node.prev){ // 首先要判断该节点是不是有前驱
if (node === this.tail){ // 有前驱，若是尾节点的话多一步，让尾指针指向当前节点的前驱
this.tail = node.prev
}
// 把当前节点的后继交接给当前节点的前驱去指向
node.prev.next = node.next
}
if (node.next) { // 判断该节点是否有后继
// 有后继的话直接让后继的前驱指向当前节点的前驱
node.next.prev = node.prev
// 整个一个过程就是把当前节点拿出来，并且保证链表不断，下面开始移动当前节点了
}
node.prev = undefiend // 移动到最前面，所以没了前驱
node.next = this.head // 注意：要先把之前的排头给接到手，让当前节点的后继指向原排头
if (this.head){
this.head.prev = node // 让之前的排头的前驱指向现在的节点
}
this.head = node // 完成了交接，才能执行此步。不然就找不到之前的排头了
return IfreturnNode? node: node.value
}
set(key, value){
// 之前的算法可以直接存k-v但是要把简单的k-v封装成一个满足双链表的节点
// 1. 查看是否已经有了该节点
let node = this.get(key, value)
if (!node) {
if (this.size === this.limit){ // 判断缓存是否达到上限
// 达到了，要删最后一个节点了
if (this.tail){
this.tail = this.tail.prev
this.tail.prev.next = undefined
// 平滑断链后，销毁当前节点
this.tail.prev = this.tail.next = undefined
this.map[this.tail.key] = undefined
// 当前缓存内存释放一个槽位
this.size--
}
node = {
key: key
}
this.map[key] = node
if (this.head) { // 判断缓存里是否有节点
this.head.prev = node
node.next = this.head
} else {
// 缓存里没有值，直接让head指向新节点就行了
this.head = node
this.tail = node
}
this.size++ // 减少一个缓存槽位
}
}
// 节点存不存在都要赋值
node.value = value
}
}
module.exports = lruCache
具体的思路就是如果所要get的节点不是头节点（即已经是最近使用的节点了，不需要移动节点位置）要先进行平滑的断链操作，处理好指针指向的关系，拿出需要移动到最前面的节点，进行链表的插入操作。
2. 写个防抖和节流函数
防抖（debounce）
常见的滚动监听事件，每次滚动都会触发，如此太过浪费性能，要如何优化呢？ 思路：在第一次触发事件的时候，不是立即执行函数，而是给出一个delay时间值，例如200ms
- 如果在200ms内没有再次触发该事件，则执行函数
- 如果在200ms内有再次触发事件，则清楚当前的计时器，重新开始计时器 效果：短时间内大量触发同一事件最终只执行一次 实现：利用setTimeOut来实现计时器的功能。
// 防抖
const debounce = (fn, delay) => {
/**
* @params [Function] fn 需要使用防抖的函数
* @params [Number] delay 毫秒，防抖期限值
*/
let timer = null
return () => {
if (timer) {
// 进入说明：当前正在一个计时周期中，并且再次触发了事件，取消当前计时，重新开始计时
clearTimeout(timer);
}
// 进入说明：当前没有计时，则开始新的计时
timer = setTimeout(fn, delay);
}
}
const showTop = () => {
let scrollTop = document.body.scrollTop || document.documentElment
console.log('当前位置：' + scrollTop)
}
window.onscroll = debounce(showTop, 1000)
定义：短时间内连续触发的事件，防抖可以让在某个时间期限内事件函数只执行一次。
节流（throttle）
需求：即使用户不断拖动滚动条，也可以在某个时间间隔后给出反馈？ 思路：设计一种类似“青蛙”的函数，即让函数执行一次后，在某个时间内暂时失效（冬眠），等过了这个时间段再重新激活（苏醒）。 效果：短时间内大量触发同一事件，函数执行一次之后再某个指定的时间内不再执行，直到过了这个指定的时间才会重新生效。 实现：状态位/时间戳/setTimeout标记
// 方案一：状态位
const throttle = (fn, delay) => {
/**
* @param [Function] fn 需要使用防抖的函数
* @param [Number] delay 毫秒，防抖期限值
*/
let valid = true
return () => {
if (!valid) {
return false
}
// 执行函数+把状态位设置为无效
valid = false
setTimeout(() => {
fn()
valid = true
}, delay)
}
}
