Jquery 幻灯片事件的延迟回调函数

我正在使用jqueryui的滑块小部件。
我希望在滑块的滑动事件上运行函数，但我只希望它在（700ms）延迟后运行。如果滑块手柄继续移动（即再次触发滑块），则我希望重置延迟超时

我尝试使用jquery的doTimeout和setTimeout，但都没有用。我所做的任何事情都会阻止滑块控制柄改变位置

var heavy = {
    updatesomething: function() {
        //some computationally heavy code
    }
}

$('#slider').slider({
    min:1, max:99, orientation: 'vertical',
    slide: function(event, ui) {
        $(this).doTimeout('timeoutid', 700, function() {
            heavy.updatesomething(this, ui.value);  });
    }
});

---

使用一个可用的去盎司实现。下面的例子取自。也可以使用如下所示的

apply

来调用具有正确上下文和参数的函数，而不是传递上下文

var重载={
更新方法：函数（事件、ui）{
console.log（this）；
控制台日志（ui）；
}
}
//取自https://davidwalsh.name/javascript-debounce-function
函数解盎司（函数、等待、立即）{
var超时；
返回函数（）{
var context=this，
args=参数；
var later=function（）{
超时=空；
如果（！immediate）函数应用（上下文，参数）；
};
var callNow=立即&&！超时；
clearTimeout（超时）；
超时=设置超时（稍后，等待）；
if（callNow）funct.apply（上下文，参数）；
};
};
$（“#滑块”）。滑块({
民:1,，
最高：99，
方向：'垂直'，
幻灯片：去盎司（功能（事件、用户界面）{
重载.updateMething.apply（这个，参数）；
//---------------------------^-上下文^——它说什么
}, 700)
});
在这种情况下，去盎司的问题是，如果用户继续移动滑块，将不会发生任何事件。因此，使用节流更有用

下面的示例还包括完整的lodash节流阀和去盎司


“严格使用”；
/**
*创建一个取消公告的函数，该函数将调用'func'延迟到'wait'之后`
*自上次执行取消公告功能以来已过毫秒
*调用。取消公告功能附带一个“cancel”方法来取消公告
*延迟的'func'调用和立即调用它们的'flush'方法。
*提供'options'，以指示是否应在上调用'func'
*“等待”超时的前缘和/或后缘。调用'func'
*最后一个参数提供给取消公告函数。后来的
*对取消公告函数的调用返回最后一个`func的结果`
*调用。
*
***注意：**如果'leading'和'trailing'选项为'true'，'func'为
*仅当取消公告的函数
*在“等待”超时期间多次调用。
*
*如果'wait'为'0'，'leading'为'false'，'func'调用将被延迟
*直到下一个刻度，类似于'setTimeout'，超时为'0'。
*
*见[大卫·科尔巴乔的文章](https://css-tricks.com/debouncing-throttling-explained-examples/)
*有关“\.debounce”和“\.throttle”之间差异的详细信息。
*
*从洛达斯-https://github.com/lodash/lodash/blob/4.16.2/lodash.js#L10218
*/
函数去盎司（函数、等待、选项）{
如果（！options）options={}；
让lastArgs、lasthis、maxWait、result、timerId、lastCallTime、lastInvokeTime=0，
领先=错误，
maxing=false，
尾随=真；
等待=等待| | 0；
领先=！！选项。领先；
maxing=选项中的“maxWait”；
maxWait=maxing？Math.max（options.maxWait | | 0，wait）：maxWait；
trailing='trailing'在选项中？！！选项。trailing:trailing；
函数invokeFunc（时间）{
常量args=lastArgs，
thisArg=lastThis；
lastArgs=lastThis=未定义；
lastInvokeTime=时间；
结果=函数应用（thisArg，args）；
返回结果；
}
功能领先优势（时间）{
//重置任何“maxWait”计时器。
lastInvokeTime=时间；
//启动后缘计时器。
timerId=setTimeout（timerExpired，wait）；
//调用前缘。
返回前导？invokeFunc（时间）：结果；
}
函数剩余等待（时间）{
const timesincellastcall=time-lastCallTime，
timeSinceLastInvoke=time-lastInvokeTime，
结果=等待-timeSinceLastCall；
返回maxing？Math.min（result，maxWait-timeSinceLastInvoke）：结果；
}
函数shouldInvoke（时间）{
const timesincellastcall=time-lastCallTime，
timeSinceLastInvoke=time-lastInvokeTime；
//要么这是第一次呼叫，活动已停止，我们处于
//后缘，系统时间倒退，我们正在处理
//它将作为后缘，否则我们将达到“maxWait”极限。
返回（lastCallTime==未定义的| |（timeSinceLastCall>=等待）||
（TimesInclastCall<0）| |（maxing&&TimesInclastInvoke>=maxWait））；
}
函数timerExpired（）{
const time=Date.now（）；
如果（应该取消（时间））{
返回拖距（时间）；
}
//重新启动计时器。
timerId=setTimeout（timerExpired，remainingWait（time））；
}
函数拖距（时间）{
timerId=未定义；
//只有在有'lastArgs'时才调用，这意味着'func'已被调用
//至少有一次脱口而出。
if（尾随参数（&lastArgs）{
返回invokeFunc（时间）；
}
lastArgs=lastThis=未定义；
返回结果；
}
函数cancel（）{
if（timerId！==未定义）{
清除超时（timerId）；
}
lastInvokeTime=0；
lastArgs=lastCallTime=lastThis=timerId=undefined；
}
函数flush（）{
return timerId==未定义？结果：trailinge（Date.now（））；
}
函数取消公告（…参数）{
const time=Date.now（），
isInvoking=应激活（时间）；
lastArgs=args；
lastThis=这个；
lastCallTime=时间；
如果（正在查看）{
if（timerId==未定义）{
返回leadingEdge（lastCallTime）；
}
如果（最大值）{
//在紧密循环中处理调用。
timerId=setTimeout（timerExpired，wait）；
返回invokeFunc（lastCallTime）；
}
}
if（timerId==未定义）{
timerId=setTimeout（timerExpired，wait）；
}
返回结果；
}
取消公告。取消=取消；
脱钩。齐平=齐平；
退场；
}
/**
*创建仅调用`