什么是防抖

函数防抖（debounce）：当持续触发事件时，一定时间段内没有再触发事件，事件处理函数才会执行一次，如果设定的时间到来之前，又一次触发了事件，就重新开始延时。如下图，持续触发 scroll 事件时，并不执行 handle 函数，当 1000 毫秒内没有触发 scroll 事件时，才会延时触发 scroll 事件。

防抖

防抖应用场景如下

  • 搜索框输入查询，如果用户一直在输入中，没有必要不停地调用去请求服务端接口，等用户停止输入的时候，再调用，设置一个合适的时间间隔，有效减轻服务端压力。
  • 表单验证
  • 按钮提交事件。
  • 浏览器窗口缩放，resize 事件(如窗口停止改变大小之后重新计算布局)等。

具体实现(Lodash 库)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
 *
 * @param { Function } func 要进行debouce的函数
 * @param { Number } wait 等待时间,默认500ms
 * @param { Boolean } immediate 是否立即执行
 */
export function debounce(func, wait = 500, immediate = false) {
  var timeout
  return function () {
    var context = this
    var args = arguments

    if (timeout) clearTimeout(timeout)
    if (immediate) {
      // 如果已经执行过，不再执行
      var callNow = !timeout
      timeout = setTimeout(function () {
        timeout = null
      }, wait)
      if (callNow) func.apply(context, args)
    } else {
      timeout = setTimeout(function () {
        func.apply(context, args)
      }, wait)
    }
  }
}

非立即执行的意思是触发事件后函数不会立即执行，而是在 n 秒后执行，如果在 n 秒内又触发了事件，则会重新计算函数执行时间。

立即执行的意思是触发事件后函数会立即执行，然后 n 秒内不触发事件才能继续执行函数的效果

什么是节流

函数节流（throttle）：当持续触发事件时，保证一定时间段内只调用一次事件处理函数。节流通俗解释就比如我们水龙头放水，阀门一打开，水哗哗的往下流，秉着勤俭节约的优良传统美德，我们要把水龙头关小点，最好是如我们心意按照一定规律在某个时间间隔内一滴一滴的往下滴。如下图，持续触发 scroll 事件时，并不立即执行 handle 函数，每隔 1000 毫秒才会执行一次 handle 函数。

节流

节流应用场景：

  • 按钮点击事件
  • 拖拽事件
  • onScoll
  • 计算鼠标移动的距离(mousemove)

具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/**
 * 节流，多次触发，间隔时间段执行
 * @param { Function } func
 * @param { Number } wait
 * @param { Object } options
 */
export function throttle(func, wait = 500, options) {
  var timeout, context, args
  var previous = 0
  if (!options) options = { leading: false, trailing: true }

  var later = function () {
    previous = options.leading === false ? 0 : new Date().getTime()
    timeout = null
    func.apply(context, args)
    if (!timeout) context = args = null
  }

  var throttled = function () {
    var now = new Date().getTime()
    if (!previous && options.leading === false) previous = now
    var remaining = wait - (now - previous)
    context = this
    args = arguments
    if (remaining <= 0 || remaining > wait) {
      if (timeout) {
        clearTimeout(timeout)
        timeout = null
      }
      previous = now
      func.apply(context, args)
      if (!timeout) context = args = null
    } else if (!timeout && options.trailing !== false) {
      timeout = setTimeout(later, remaining)
    }
  }
  return throttled
}

第三个参数还有点复杂，options

  • leading，函数在每个等待时延的开始被调用，默认值为 false
  • trailing，函数在每个等待时延的结束被调用，默认值是 true

leading-false，trailing-true：默认情况，即在延时结束后才会调用函数

leading-true，trailing-true：在延时开始时就调用，延时结束后也会调用

leading-true, trailing-false：只在延时开始时调用

总结

  • 函数防抖

    将几次操作合并为一此操作进行。原理是维护一个计时器，规定在 delay 时间后触发函数，但是在 delay 时间内再次触发的话，就会取消之前的计时器而重新设置。这样一来，只有最后一次操作能被触发。

    1. input 框搜索，用户在不断输入值时，用防抖来节约请求资源。
    2. window 触发 resize 的时候，不断的调整浏览器窗口大小会不断的触发这个事件，用防抖来让其只触发一次。

  • 函数节流

    使得一定时间内只触发一次函数。原理是通过判断是否到达一定时间来触发函数。

    1. 鼠标不断点击触发，mousedown(单位时间内只触发一次)
    2. 监听滚动事件，比如是否滑到底部自动加载更多，用 throttle 来判断

  • 区别

    函数节流不管事件触发有多频繁，都会保证在规定时间内一定会执行一次真正的事件处理函数

    而函数防抖只是在最后一次事件后才触发一次函数。 比如在页面的无限加载场景下，我们需要用户在滚动页面时，每隔一段时间发一次 Ajax 请求，而不是在用户停下滚动页面操作时才去请求数据。这样的场景，就适合用节流技术来实现。

文章参考