如何解決js函數防抖、節流出現的問題

來源：懂視網責編：小采時間：2020-11-27 21:55:02

如何解決js函數防抖、節流出現的問題

如何解決js函數防抖、節流出現的問題:React中使用防抖函數和節流函數在React事件調用時，React傳遞給事件處理程序是一個合成事件對象的實例。SyntheticEvent對象是通過合并得到的。這意味著在事件回調被調用后，SyntheticEvent 對象將被重用并且所有屬性都將被取消。這是出于性能原因。因

推薦度：

點擊下載本文 文檔為doc格式

導讀如何解決js函數防抖、節流出現的問題:React中使用防抖函數和節流函數在React事件調用時，React傳遞給事件處理程序是一個合成事件對象的實例。SyntheticEvent對象是通過合并得到的。這意味著在事件回調被調用后，SyntheticEvent 對象將被重用并且所有屬性都將被取消。這是出于性能原因。因

React中使用防抖函數和節流函數

在React事件調用時，React傳遞給事件處理程序是一個合成事件對象的實例。SyntheticEvent對象是通過合并得到的。這意味著在事件回調被調用后，SyntheticEvent 對象將被重用并且所有屬性都將被取消。這是出于性能原因。因此，您無法以異步方式訪問該事件。React合成事件官方文檔

所以在用防抖或節流函數封裝時，異步方式訪問事件對象出現問題。解決的方法如下：

方法一：調用合成事件對象的persist()方法 event.persist && event.persist() //保留對事件的引用

方法二：深拷貝事件對象 const event = e && {...e} //深拷貝事件對象

function debounce(func, wait=500) {
let timeout; // 定時器變量
return function(event){
clearTimeout(timeout); // 每次觸發時先清除上一次的定時器,然后重新計時
event.persist && event.persist() //保留對事件的引用
//const event = e && {...e} //深拷貝事件對象
timeout = setTimeout(()=>{
func(event)
}, wait); // 指定 xx ms 后觸發真正想進行的操作 handler
};
}

防抖debounce

防抖 Debounce 多次觸發，只在最后一次觸發時，執行目標函數。

函數防抖就是，延遲一段時間再執行函數，如果這段時間內又觸發了該函數，則延遲重新計算。

應用場景

（1）通過監聽某些事件完成對應的需求，比如：

通過監聽 scroll 事件，檢測滾動位置，根據滾動位置顯示返回頂部按鈕

通過監聽 resize 事件，對某些自適應頁面調整DOM的渲染（通過CSS實現的自適應不再此范圍內）

通過監聽 keyup 事件，監聽文字輸入并調用接口進行模糊匹配

（2）其他場景

表單組件輸入內容驗證

防止多次點擊導致表單多次提交

簡單實現

function debounce(fn, wait) {
let t
return () => {
let context = this
let args = arguments
if (t) clearTimeout(t)
t= setTimeout(() => {
fn.apply(context, args)
}, wait)
}
}

完整實現

function debounce(func, wait, immediate) {
let time;
let debounced = function() {
let context = this;
if(time) clearTimeout(time);
if(immediate) {
let callNow = !time;
if(callNow) func.apply(context, arguments);
time = setTimeout(
()=>{time = null} //見注解
, wait)
} else {
time = setTimeout(
()=>{func.apply(context, arguments)}
, wait) 
}
};
debounced.cancel = function() {
clearTimeout(time);
time = null
};
return debounced
}
// underscore.js debounce
//
// Returns a function, that, as long as it continues to be invoked, will not
// be triggered. The function will be called after it stops being called for
// N milliseconds. If `immediate` is passed, trigger the function on the
// leading edge, instead of the trailing.
_.debounce = function(func, wait, immediate) {
var timeout, args, context, timestamp, result;
// 處理時間
var later = function() {
var last = _.now() - timestamp;
if (last < wait && last >= 0) {
timeout = setTimeout(later, wait - last); // 10ms 6ms 4ms
} else {
timeout = null;
if (!immediate) {
result = func.apply(context, args);
if (!timeout) context = args = null;
}
}
};

react中調用方法

this.handleGetCustomerNameList = debounce(this.handleGetCustomerNameList.bind(this), 500);

節流 throttle

節流：函數間隔一段時間后才能再觸發，避免某些函數觸發頻率過高，比如滾動條滾動事件觸發的函數。

### 簡單實現
function throttle (fn, wait, mustRun) {
let start = new Date()
let timeout
return () => {
// 在返回的函數內部保留上下文和參數
let context = this
let args = arguments
let current = new Date()
clearTimeout(timeout)
let remaining = current - start
// 達到了指定觸發時間，觸發該函數
if (remaining > mustRun) {
fn.apply(context, args)
start = current
} else {
// 否則wait時間后觸發，閉包保留一個timeout實例
timeout = setTimeout(fn, wait);
}
}
}

完整實現

function throttle(func, wait, options) {
let time, context, args, result;
let previous = 0;
if (!options) options = {};
let later = function () {
previous = options.leading === false ? 0 : new Date().getTime();
time = null;
func.apply(context, args);
if (!time) context = args = null;
};
let throttled = function () {
let now = new Date().getTime();
if (!previous && options.leading === false) previous = now;
let remaining = wait - (now - previous);
context = this;
args = arguments;
if (remaining <= 0 || remaining > wait) {
if (time) {
clearTimeout(time);
time = null;
}
previous = now;
func.apply(context, args);
if (!time) context = args = null;
} else if (!time && options.trailing !== false) {
time = setTimeout(later, remaining);
}
};
return throttled;
}
// underscore.js throttle
// Returns a function, that, when invoked, will only be triggered at most once
// during a given window of time. Normally, the throttled function will run
// as much as it can, without ever going more than once per `wait` duration;
// but if you'd like to disable the execution on the leading edge, pass
// `{leading: false}`. To disable execution on the trailing edge, ditto.
_.throttle = function(func, wait, options) {
var context, args, result;
var timeout = null;
var previous = 0;
if (!options) options = {};
var later = function() {
previous = options.leading === false ? 0 : _.now();
timeout = null;
result = func.apply(context, args);
if (!timeout) context = args = null;
};
return function() {
var now = _.now();
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;
result = func.apply(context, args);
if (!timeout) context = args = null;
} else if (!timeout && options.trailing !== false) {
timeout = setTimeout(later, remaining);
}
return result;
};
};

react中調用方法

this.handleGetCustomerNameList = throttle (this.handleGetCustomerNameList.bind(this), 500);

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。TEL:177 7030 7066 E-MAIL:11247931@qq.com