要获取最后一次执行的结果,核心思路是将异步操作(如网络请求)的 promise 对象保存在防抖或节流的内部状态中,并在触发回调时返回该 promise。这样调用者可以通过 `.then()` 或 `await` 直接拿到最终的计算结果或响应数据,而不是仅仅知道函数被触发了。

如何封装支持返回值的防抖函数
在实现防抖时,需要利用闭包保存当前正在执行的 Promise。每次触发时,如果存在旧的 Promise,则忽略本次触发;如果不存在,则创建新的 Promise 并启动定时器。当定时器超时且没有新触发时,执行实际逻辑并 resolve 该 Promise。这种模式确保了只有最后一次有效的触发才会产生返回值。

function debounce(fn, delay) {
let timer = null;
let lastPromise = null;
return function (...args) {
// 如果有正在进行的任务,直接返回上一次的 Promise
if (lastPromise) {
return lastPromise;
}
// 创建新的 Promise 用于承载最终结果
lastPromise = new Promise((resolve, reject) => {
clearTimeout(timer);
timer = setTimeout(() => {
try {
// 执行原函数,捕获其返回值
const result = fn.apply(this, args);
resolve(result);
} catch (error) {
reject(error);
} finally {
// 清理状态
lastPromise = null;
timer = null;
}
}, delay);
});
return lastPromise;
};
}
// 使用示例
const fetchData = async (id) => {
const response = await fetch(`/api/data/${id}`);
return response.json();
};
const debouncedFetch = debounce(fetchData, 300);
// 获取最后一次调用的结果
debouncedFetch(1).then(data => console.log('Result:', data));
debouncedFetch(2); // 这次调用会被忽略,因为上一次还没结束
上述代码展示了完整的防抖封装。关键点在于 lastPromise 的状态管理。当 debounce 返回的函数被调用时,它首先检查是否已有未完成的 Promise。如果有,说明前一次调用尚未完成,直接返回旧 Promise,从而保证调用者始终持有同一个结果引用。如果没有,则创建新的 Promise 并设置定时器。定时器回调中执行实际函数,并将结果通过 resolve 传递出去。最后,无论成功还是失败,都要清空 lastPromise 和 timer,以便下一次触发可以重新开始。
如何封装支持返回值的节流函数
节流的不同之处在于它允许在间隔期内多次触发,但只执行一次。为了获取最后一次执行的结果,我们需要在每次触发时更新当前的 Promise。如果当前没有正在执行的 Promise,或者上一个 Promise 已经 resolved/rejected,我们就创建一个新的 Promise 并立即执行(或在下个 tick 执行)。如果上一个 Promise 还在 pending 状态,我们通常不执行新逻辑,但可以更新一个标志位,表示“有更新的请求”,以便在下一次执行时处理最新的数据。更简单的做法是:每次触发都尝试获取最新的 Promise,如果当前没有可执行的窗口,则等待下一个窗口,并将结果关联到最新的调用上。

function throttle(fn, interval) {
let lastTime = 0;
let lastPromise = null;
return function (...args) {
const now = Date.now();
const remaining = interval - (now - lastTime);
// 如果距离上次执行时间不足 interval,且没有正在进行的 Promise
// 这里我们采用一种策略:总是返回最新的 Promise
// 如果当前处于冷却期,我们可能需要等待或立即执行取决于需求
// 对于“获取最后一次结果”,通常意味着我们关心的是最近一次触发的结果
if (remaining {
try {
const result = fn.apply(this, args);
resolve(result);
} catch (error) {
reject(error);
}
});
return lastPromise;
} else {
// 在冷却期内
// 如果已经有 Promise 在执行,返回它
// 如果没有,创建一个将在冷却结束后执行的 Promise
if (!lastPromise || lastPromise.status === 'settled') {
lastPromise = new Promise((resolve, reject) => {
setTimeout(() => {
lastTime = Date.now();
try {
const result = fn.apply(this, args);
resolve(result);
} catch (error) {
reject(error);
}
lastPromise = null;
}, remaining);
});
}
return lastPromise;
}
};
}
// 使用示例
const handleResize = throttle((width) => {
console.log('Window width:', width);
return { width, height: window.innerHeight };
}, 500);
handleResize().then(res => console.log('Throttle Result:', res));
节流的实现比防抖复杂,因为它涉及时间窗口的管理。在上述代码中,我们维护了 lastTime 和 lastPromise。当触发发生时,计算剩余时间。如果剩余时间为负或零,说明可以立即执行,更新 lastTime 并创建新的 Promise。如果处于冷却期,我们检查 lastPromise 的状态。如果它是空的或已结算,我们创建一个将在剩余时间后执行的 Promise。这确保了即使在冷却期内触发,调用者也能获得一个 Promise,该 Promise 将在冷却期结束后解析为最新一次调用的结果。这种方法保证了“最后一次”触发的结果能被正确捕获,即使它在冷却期内被触发。
如何处理异步函数中的错误与取消
在实际应用中,异步函数可能会抛出错误或需要被取消。在防抖和节流中,我们需要妥善处理这些情况。对于错误,我们在 Promise 的 catch 块中捕获异常,并通过 reject 传递给调用者。对于取消,我们可以引入一个 AbortController 或类似的机制,在每次新触发时取消之前的请求。例如,在防抖中,如果新的触发到来,我们可以清除之前的定时器,并标记之前的 Promise 为已取消。调用者可以通过检查 Promise 的状态或捕获特定的错误来判断是否被取消。此外,如果原函数本身支持取消(如 Fetch API 的 AbortSignal),我们应该将取消信号传递给原函数,以确保资源被正确释放。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南











