什么是JavaScript的防抖与节流

admin

　　这篇文章主要介绍了什么是JavaScript的防抖与节流,防抖是在频繁触发某一个事件时，一段时间内不再触发该事件后才会去调用对应的回调函数，在设定间隔时间内如果下一次事件被触发， 那么就重新开始定时器，直到事件触发结束，节流看下面文章的具体介绍吧

一、函数防抖（debounce）


1. 什么是防抖？

2. 函数防抖： 在频繁触发某一个事件时，一段时间内不再触发该事件后才会去调用对应的回调函数，在设定间隔时间内如果下一次事件被触发， 那么就重新开始定时器，直到事件触发结束。

复制代码

　　规定时间内没有继续触发事件的前提下，再去调用事件处理函数；
　　具体如下面的例子所示：

2. /*定义防抖函数
3. * func：传入一个函数，事件不再持续触发时会调用该函数
4. * delay:定义持续多久后执行传入的回调函数
5. * */
6. function debounce(func,delay) {
7.   let timer = null  // 用于保存定时器
8.   return function (...args) {
9.    // 如果定时器存在，清除定时器，随后重新设置timer
10.    if(timer !== null) clearTimeout(timer)
11.    timer = setTimeout(func, delay)  // 超过delay为接收到事件会调用这里的func   必要的额时候可以修改func的this指向  由于timer对外部存在引用，因此不会被销毁
12.   }
13. }
15. /*事件处理函数*/
16. function testDeBounce(){
17.   console.log('你看我执行了几次？？')
18. }
20. // 接收debounce返回的函数
21. const temp = debounce(testDeBounce(),1000)
23. /*绑定事件，测试防抖函数*/
24. window.addEventListener('scroll',()=>{
25.   temp()
26. }); // 这样写最少调用一次事件处理函数，最多也不会多余下面的写法执行的次数
27. window.addEventListener('scroll', testDeBounce); // 如果这样写的话，每当页面滚动就会调用事件处理函数

复制代码

　　总结一下思路：

   

• 1.定义一个节流函数   
  
• 2.函数内部使用一个变量保存定时器   
  
• 3.返回一个函数，函数内部定义：如果定时器已经存在就清除定时器，重新设置定时器   
  
• 4.定义一个变量来接收debounce返回的函数   
  
• 5.在事件的回调函数中直接调用上一步的变量接收的方法
  

二、函数节流

2. 函数节流： 在事件持续触发的前提下，保证一定时间段内只调用一次事件处理函数，就是函数节流；

复制代码

　　函数节流实现的方式： 定时器、时间戳、定时器+时间戳；

2.1 定时器实现

　　思路：

   

• 1.定义节流函数throttle   
  
• 2.定义timer保存定时器   
  
• 3.返回一个函数。函数内部定义：如果定时器不存在，设置定时器，间隔某一时间后将timer设置为null，如果在这之前事件再次触发，则定时器中的回调无效
  

　　‹button>这是一个孤独的按钮‹/button>

2. /*
3. * 定义定时器节流函数
4. * func:传入事件处理函数
5. * delay：在delay指定的时间内定时器回调无效
6. * */
7. function throttle(func,delay) {
8.   let timer = null
9.   const context = this
10.   return function(...args){
11.    // 如果定时器不存在
12.    if(!timer){
13.     timer = setTimeout(()=>{
14.      func.apply(context,args) // 考虑返回的函数调用的环境，因此这里不直接使用this
15.      timer = null // delay之后清除定时器
16.     },delay)
17.    }
18.   }
19. }
21. function test() {
22.   console.log('啊啊啊！')
23. }
25. const temp = throttle(test,1000)
27. document.querySelector('button').addEventListener('click',()=>{
28.   temp()
29. })

复制代码

2.2 时间戳实现

2. var throttle = function(func, delay) {            
3. 　　var prev = Date.now();            
4. 　　return function() {               
5. 　　　　var context = this;               
6. 　　　　var args = arguments;               
7. 　　　　var now = Date.now();               
8. 　　　　if (now - prev >= delay) {                    
9. 　　　　　　func.apply(context, args);                    
10. 　　　　　　prev = Date.now();               
11. 　　　　}            
12. 　　}        
13. }   
15. function handle() {            
16. 　　console.log(Math.random());        
17. }        
19. window.addEventListener('scroll', throttle(handle, 1000));

复制代码

2.3 时间戳+定时器

2. // 节流throttle代码（时间戳+定时器）：
3. var throttle = function(func, delay) {     
4.     var timer = null;     
5.     var startTime = Date.now();     
6.     return function() {            
7.         var curTime = Date.now();            
8.         var remaining = delay - (curTime - startTime);            
9.         var context = this;            
10.         var args = arguments;            
11.         clearTimeout(timer);              
12.         if (remaining ‹= 0) {                    
13.             func.apply(context, args);                    
14.             startTime = Date.now();              
15.         } else {                    
16.             timer = setTimeout(func, remaining);              
17.         }      
18.     }
19. }
21. function handle() {      
22.     console.log(Math.random());
23. }
25. window.addEventListener('scroll', throttle(handle, 1000));

复制代码

　　到此这篇关于什么是JavaScript的防抖与节流的文章就介绍到这了,更多相关JavaScript的防抖与节流内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

---