防抖 在一定时间间隔内，多次调用一个方法，只会执行一次.

在一定时间间隔内，多次调用一个方法，只会执行一次.

/**

* @param {Function} func

* @param {number} wait

* @param {boolean} immediate

* @return {*}

*/

function debounce(func, wait, immediate) {

  let timeout, args, context, timestamp, result

  const later = function() {

    // 据上一次触发时间间隔

    const last = +new Date() - timestamp

    // 上次被包装函数被调用时间间隔 last 小于设定时间间隔 wait

    if (last < wait && last > 0) {

      timeout = setTimeout(later, wait - last)

    } else {

      timeout = null

      // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用

      if (!immediate) {

        result = func.apply(context, args)

        if (!timeout) context = args = null} } }

  return function(...args) {

    context = this

    timestamp = +new Date()

    const callNow = immediate && !timeout

    // 如果延时不存在，重新设定延时

    if (!timeout) timeout = setTimeout(later, wait)

    if (callNow) {

      result = func.apply(context, args)

      context = args = null}

    return result

  }}

2.

/**

* 防抖

* @param {Function} func 要执行的回调函数

* @param {Number} wait 延时的时间

* @param {Boolean} immediate 是否立即执行

* @return null

*/

let timeout;

export default function Debounce(func, wait = 3000, immediate = true) {

  // 清除定时器

  if (timeout !== null) clearTimeout(timeout);

  // 立即执行，此类情况一般用不到

  if (immediate) {

    var callNow = !timeout;

    timeout = setTimeout(function() {

      timeout = null;

    }, wait);

    if (callNow) typeof func === 'function' && func();

  } else {

    // 设置定时器，当最后一次操作后，timeout不会再被清除，所以在延时wait毫秒后执行func回调方法

    timeout = setTimeout(function() {

      typeof func === 'function' && func();

    }, wait); }}

//使用

Debounce(()=>{

console.log(1);

});