function debounce(func, wait, immediate = false) {
  let timeout = null;
  // 返回包裝后的防抖函數(shù)
  return function (...args) {
    const context = this;
    // 如果定時器存在，清除之前的定時器（取消未執(zhí)行的延遲操作）
    if (timeout) clearTimeout(timeout);
    if (immediate) {
      // 立即執(zhí)行模式：首次觸發(fā)立即執(zhí)行，后續(xù)在 wait 時間內觸發(fā)則重新計時
      const callNow = !timeout;
      timeout = setTimeout(() => {
        timeout = null; // 恢復可執(zhí)行狀態(tài)
      }, wait);
      if (callNow) func.apply(context, args);
    } else {
      // 延遲執(zhí)行模式：最后一次觸發(fā)后等待 wait 時間再執(zhí)行
      timeout = setTimeout(() => {
        func.apply(context, args);
      }, wait);
    }
  };
}

<input type="text" id="searchInput" />
<script>
  const searchInput = document.getElementById('searchInput');
  // 原始搜索函數(shù)
  function search(query) {
    console.log('搜索關鍵詞:', query);
  }
  // 防抖處理（延遲執(zhí)行）
  const debouncedSearch = debounce(search, 500);
  // 綁定輸入事件
  searchInput.addEventListener('input', function (e) {
    debouncedSearch(e.target.value);
  });
</script>

<button id="submitBtn">提交</button>
<script>
  const submitBtn = document.getElementById('submitBtn');
  // 原始提交函數(shù)
  function submitForm() {
    console.log('表單已提交');
  }
  // 防抖處理（立即執(zhí)行）
  const debouncedSubmit = debounce(submitForm, 1000, true);
  // 綁定點擊事件
  submitBtn.addEventListener('click', debouncedSubmit);
</script>

function throttle(func, wait) {
  let previous = 0; // 上次執(zhí)行時間戳
  return function (...args) {
    const now = Date.now();
    const context = this;
    if (now - previous > wait) {
      func.apply(context, args);
      previous = now; // 更新執(zhí)行時間戳
    }
  };
}

function throttle(func, wait) {
  let timeout = null;
  return function (...args) {
    const context = this;
    if (!timeout) {
      timeout = setTimeout(() => {
        timeout = null; // 重置定時器
        func.apply(context, args);
      }, wait);
    }
  };
}

function throttle(func, wait) {
  let previous = 0;
  let timeout = null;
  return function (...args) {
    const context = this;
    const now = Date.now();
    const remaining = wait - (now - previous);
    if (remaining <= 0) {
      // 立即執(zhí)行
      if (timeout) {
        clearTimeout(timeout);
        timeout = null;
      }
      func.apply(context, args);
      previous = now;
    } else if (!timeout) {
      // 設置最后一次執(zhí)行的定時器
      timeout = setTimeout(() => {
        func.apply(context, args);
        timeout = null;
        previous = Date.now();
      }, remaining);
    }
  };
}

<div id="scrollArea" style="height: 2000px;"></div>
<script>
  const scrollArea = document.getElementById('scrollArea');
  // 原始滾動處理函數(shù)
  function handleScroll() {
    console.log('滾動位置:', window.scrollY);
  }
  // 節(jié)流處理（時間戳方式）
  const throttledScroll = throttle(handleScroll, 200);
  // 綁定滾動事件
  window.addEventListener('scroll', throttledScroll);
</script>

<button id="clickBtn">點擊</button>
<script>
  const clickBtn = document.getElementById('clickBtn');
  // 原始點擊處理函數(shù)
  function handleClick() {
    console.log('按鈕點擊');
  }
  // 節(jié)流處理（定時器方式）
  const throttledClick = throttle(handleClick, 1000);
  // 綁定點擊事件
  clickBtn.addEventListener('click', throttledClick);
</script>

//防抖簡單寫法
function debounce(func, t) {
  let timer = null
  return function () {
    if (timer) {
      clearTimeout(timer)
    }
    timer = setTimeout(() => func(), t)
  }
}

//節(jié)流簡單寫法
function throttle(func, t) {
  let timer = null
  return function () {
    if (!timer) {
      timer = setTimeout(() => {
        func()
        timer = null
      }, t)
    }
  }
}

_.throttle(func, [wait=0], [options={}])

function throttle(func, wait, options) {
  let leading = true;
  let trailing = true;
  // 參數(shù)處理
  if (typeof options === 'object') {
    leading = 'leading' in options ? !!options.leading : leading;
    trailing = 'trailing' in options ? !!options.trailing : trailing;
  }
  let lastArgs, lastThis, result;
  let timeout = null;
  let previous = 0;
  const throttled = function(...args) {
    const now = Date.now();
    // 首次調用且不執(zhí)行 leading 時，設置 previous 為 now
    if (!previous && leading === false) previous = now;
    // 計算剩余時間
    const remaining = wait - (now - previous);
    // 需要執(zhí)行（剩余時間 <=0 或系統(tǒng)時間被修改）
    if (remaining <= 0 || remaining > wait) {
      if (timeout) {
        clearTimeout(timeout);
        timeout = null;
      }
      previous = now;
      result = func.apply(this, args);
    } else if (!timeout && trailing !== false) {
      // 設置尾調用的定時器
      timeout = setTimeout(() => {
        previous = leading === false ? 0 : Date.now();
        timeout = null;
        result = func.apply(lastThis, lastArgs);
      }, remaining);
    }
    return result;
  };
  // 提供取消方法
  throttled.cancel = function() {
    clearTimeout(timeout);
    previous = 0;
    timeout = lastArgs = lastThis = null;
  };
  return throttled;
}

_.debounce(func, [wait=0], [options={}])

function debounce(func, wait, options) {
  let lastArgs, lastThis, result;
  let timerId = null;
  let lastCallTime = 0;
  let leading = false;
  let maxing = false;
  let maxWait;
  // 參數(shù)處理
  if (typeof options === 'object') {
    leading = !!options.leading;
    maxing = 'maxWait' in options;
    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;
  }
  const invokeFunc = (time) => {
    const args = lastArgs;
    const thisArg = lastThis;
    lastArgs = lastThis = undefined;
    result = func.apply(thisArg, args);
    return result;
  };
  const leadingEdge = (time) => {
    // 記錄最后一次調用時間
    lastCallTime = time;
    // 設置定時器
    timerId = setTimeout(timerExpired, wait);
    // 立即執(zhí)行模式
    return leading ? invokeFunc(time) : result;
  };
  const shouldInvoke = (time) => {
    // 判斷是否需要執(zhí)行（超過 wait 或 maxWait）
    const timeSinceLastCall = time - lastCallTime;
    return (lastCallTime === 0) || (timeSinceLastCall >= wait) || 
           (maxing && timeSinceLastCall >= maxWait);
  };
  const debounced = function(...args) {
    const time = Date.now();
    lastArgs = args;
    lastThis = this;
    // 判斷是否應該執(zhí)行
    const isInvoking = shouldInvoke(time);
    if (isInvoking) {
      // 清除已有定時器
      if (timerId === null) {
        return leadingEdge(time);
      }
      // 處理 maxWait 場景
      if (maxing) {
        timerId = setTimeout(timerExpired, wait);
        return invokeFunc(time);
      }
    }
    // 設置/重置定時器
    if (timerId === null) {
      timerId = setTimeout(timerExpired, wait);
    }
    return result;
  };
  // 提供取消和立即執(zhí)行方法
  debounced.cancel = function() { /* ... */ };
  debounced.flush = function() { /* ... */ };
  return debounced;
}