面试题

✨ 介绍防抖节流原理、区别以及应用，并用JavaScript进行实现

1. 防抖

• 原理：在事件被触发n秒后再执行回调，如果在这n秒内又被触发，则重新计时。

• 适用场景：

  • 按钮提交场景：防止多次提交按钮，只执行最后提交的一次
  • 搜索框联想场景：防止联想发送请求，只发送最后一次输入

// 简易版实现
function debounce(func, wait=1000) {
    let timeout;
    return function (args) {
        clearTimeout(timeout)
        timeout = setTimeout(function(){
            func.apply(this, args)
        }, wait);
    }
}

// 立即执行版实现,有时希望立刻执行函数，然后等到停止触发 n 秒后，才可以重新触发执行。
function debounce(func, wait=5000, immediate=true) {
    let timeout;
    return function (args) {
        if (timeout) clearTimeout(timeout);
        if (immediate) {
            const callNow = !timeout;
            timeout = setTimeout(function () {
                timeout = null;
            }, wait)
            if (callNow) func.apply(this, args)
        } else {
            timeout = setTimeout(function () {
                func.apply(this, args)
            }, wait);
        }
    }
}

/**
func函数可能会有返回值，所以需要返回函数结果，
但是当 immediate 为 false 的时候
因为使用了 setTimeout 
我们将 func.apply(context, args) 的返回值赋给变量
最后再 return 的时候，值将会一直是 undefined
所以只在 immediate 为 true 的时候返回函数的执行结果
*/
function debounce(func, wait, immediate) {
    let timeout, result;
    return function (args) {
        if (timeout) clearTimeout(timeout);
        if (immediate) {
            const callNow = !timeout;
            timeout = setTimeout(function () {
                timeout = null;
            }, wait)
            if (callNow) result = func.apply(this, args)
        }
        else {
            timeout = setTimeout(function () {
                func.apply(this, args)
            }, wait);
        }
        return result;
    }
}

2. 节流

• 原理：规定在一个单位时间内，只能触发一次函数。如果这个单位时间内触发多次函数，只有一次生效。

• 适用场景：

  • 拖拽场景：固定时间内只执行一次，防止超高频次触发位置变动
  • 缩放场景：监控浏览器resize

/* 使用时间戳实现
使用时间戳，当触发事件的时候，我们取出当前的时间戳，
然后减去之前的时间戳(最一开始值设为 0 )，
如果大于设置的时间周期，就执行函数，
然后更新时间戳为当前的时间戳，如果小于，就不执行。
*/
function throttle(func, wait) {
  let previous = 0;
  return function (args) {
    let now = +new Date();
    if (now - previous > wait) {
      func.apply(this, args);
      previous = now;
    }
  }
}

/*使用定时器实现
当触发事件的时候，我们设置一个定时器，
再触发事件的时候，如果定时器存在，就不执行，直到定时器执行，
然后执行函数，清空定时器，这样就可以设置下个定时器。
*/
function throttle(func, wait) {
  let timeout;
  return function (args) {
    if (!timeout) {
      timeout = setTimeout(function () {
        timeout = null;
        func.apply(this, args)
      }, wait)
    }

  }
}

/** 防抖:
 * 应用场景：当用户进行了某个行为(例如点击)之后。
 不希望每次行为都会触发方法，而是行为做出后,
 一段时间内没有再次重复行为，
 * 才给用户响应
 * 实现原理 : 每次触发事件时设置一个延时调用方法，
 并且取消之前的延时调用方法。
 （每次触发事件时都取消之前的延时调用方法）
 *  @params fun 传入的防抖函数(callback) delay 等待时间
 *  */
const debounce = (fun, delay = 500) => {
    let timer = null //设定一个定时器
    return function (...args) {
        clearTimeout(timer);
        timer = setTimeout(() => {
            fun.apply(this, args)
        }, delay)
    }
}

/** 节流
 *  应用场景:用户进行高频事件触发(滚动)，
 但在限制在n秒内只会执行一次。
 *  实现原理: 每次触发时间的时候，
 判断当前是否存在等待执行的延时函数
 * @params fun 传入的防抖函数(callback) delay 等待时间
 * */

const throttle = (fun, delay = 1000) => {
    let flag = true;
    return function (...args) {
        if (!flag) return;
        flag = false
        setTimeout(() => {
            fun.apply(this, args)
            flag = true
        }, delay)
    }
}

区别:节流不管事件触发多频繁保证在一定时间内一定会执行一次函数。防抖是只在最后一次事件触发后才会执行一次函数

对闭包的看法，为什么要用闭包？说一下闭包原理以及应用场景

1. 什么闭包

函数执行后返回结果是一个内部函数，并被外部变量所引用，如果内部函数持有被执行函数作用域的变量，即形成了闭包。

可以在内部函数访问到外部函数作用域。使用闭包，一可以读取函数中的变量，二可以将函数中的变量存储在内存中，保护变量不被污染。而正因闭包会把函数中的变量值存储在内存中，会对内存有消耗，所以不能滥用闭包，否则会影响网页性能，造成内存泄漏。当不需要使用闭包时，要及时释放内存，可将内层函数对象的变量赋值为null。

2. 闭包原理

函数执行分成两个阶段(预编译阶段和执行阶段。
*   在预编译阶段，如果发现内部函数使用了外部函数的变量，则会在内存中创建一个“闭包”对象并保存对应变量值，如果已存在“闭包”，则只需要增加对应属性值即可。
*   执行完后，函数执行上下文会被销毁，函数对“闭包”对象的引用也会被销毁，但其内部函数还持用该“闭包”的引用，所以内部函数可以继续使用“外部函数”中的变量
利用了函数作用域链的特性，一个函数内部定义的函数会将包含外部函数的活动对象添加到它的作用域链中，函数执行完毕，其执行作用域链销毁，但因内部函数的作用域链仍然在引用这个活动对象，所以其活动对象不会被销毁，直到内部函数被烧毁后才被销毁。

3. 优点

1. 对内存消耗有负面影响。因内部函数保存了对外部变量的引用，导致无法被垃圾回收，增大内存使用量，所以使用不当会导致内存泄漏
2. 对处理速度具有负面影响。闭包的层级决定了引用的外部变量在查找时经过的作用域链长度
3. 可能获取到意外的值(captured value)

4. 应用场景

// 应用场景一： 典型应用是模块封装，在各模块规范出现之前，都是用这样的方式防止变量污染全局。
var Yideng = (function () {
    // 这样声明为模块私有变量，外界无法直接访问
    var foo = 0;

    function Yideng() {}
    Yideng.prototype.bar = function bar() {
        return foo;
    };
    return Yideng;
}());