javascript 防抖与节流支持异步函数的核心做法是让包装器返回 promise，并在内部使用 async/await 等待异步操作完成后再更新状态或触发回调。这样调用方可以直接通过 .then() 获取最终结果，而无需关心内部的定时器逻辑。具体实现时，需将 settimeout 的回调改为 await 后的执行步骤，并确保在清除定时器时也处理了未完成的 promise。
如何实现支持异步操作的防抖函数
防抖函数在异步场景下需要确保最后一次触发的请求完成后，才允许下一次触发生效。实现时需维护一个 pending Promise，如果新事件在间隔内触发且存在未完成的请求，则取消旧请求并启动新请求。以下代码展示了基于 Promise 的防抖实现：
function debounceAsync(fn, delay) {
let timer = null;
let pendingPromise = null;
return function (...args) {
// 如果有正在进行的请求，取消它（这里简化为忽略，实际可结合 AbortController）
if (timer) clearTimeout(timer);
return new Promise((resolve, reject) => {
timer = setTimeout(async () => {
try {
const result = await fn.apply(this, args);
resolve(result);
} catch (error) {
reject(error);
}
pendingPromise = null;
}, delay);
});
};
}
预期结果：连续快速调用 debounceAsync(fetchData)，只有最后一次调用会真正发起请求并返回结果，前几次调用的 Promise 会被忽略或等待最后一次完成（取决于具体实现策略，上述代码中前几次调用因 timer 被重置而未执行，其 Promise 不会 resolve，需根据业务需求处理废弃逻辑）。
如何实现支持异步操作的节流函数
节流函数在异步场景下通常有两种策略：一种是“立即执行版”，即第一次触发立即执行，之后在间隔内忽略；另一种是“ trailing edge 版”，即在间隔结束时执行最后一次。对于异步操作，关键在于防止并发请求导致的状态混乱。以下代码展示了一种简单的 trailing edge 节流：
function throttleAsync(fn, interval) {
let lastTime = 0;
let timer = null;
return function (...args) {
const now = Date.now();
const remaining = interval - (now - lastTime);
if (remaining {
timer = setTimeout(async () => {
try {
const result = await fn.apply(this, args);
resolve(result);
} catch (error) {
reject(error);
}
timer = null;
lastTime = Date.now();
}, remaining);
});
}
// 如果在间隔内且已有定时器，可以选择忽略或排队
return null;
};
}
预期结果：在 interval 时间内多次调用 throttleAsync(saveData)，只有第一次和间隔结束后的第一次会实际执行 fn，中间调用的 Promise 不会被 resolve（返回 null），从而避免重复提交。
异步防抖中如何处理取消未完成的请求
在实际应用中，如网络请求，取消未完成的请求非常重要以避免资源浪费和数据不一致。可以通过引入 AbortController 来实现。当新的防抖触发发生时，中止之前的请求控制器，并创建新的控制器传递给异步函数。
async function fetchDataWithAbort(url, signal) {
const response = await fetch(url, { signal });
return response.json();
}
function debounceAsyncWithCancel(fn, delay) {
let timer = null;
let currentController = null;
return function (...args) {
if (timer) clearTimeout(timer);
if (currentController) currentController.abort();
const controller = new AbortController();
currentController = controller;
return new Promise((resolve, reject) => {
timer = setTimeout(async () => {
if (controller.signal.aborted) return;
try {
const result = await fn(...args, controller.signal);
resolve(result);
} catch (error) {
if (error.name !== 'AbortError') reject(error);
}
}, delay);
});
};
}
该实现确保了在防抖延迟期间，如果用户再次触发，之前的请求会被中止，只有最后一次触发的请求会完整执行并返回结果。
Java免费学习笔记：立即使用
解锁 Java 大师之旅：从入门到精通的终极指南
