从闭包看作用域

export function debounce(fn, delay) {
  let timer = null;
  return function() {
    let context = this;
    let arg = arguments;
    clearTimeout(timer);
    timer = setTimeout(function() {
      fn.apply(context, arg);
    }, delay);
  };
}

function log(str) {
    console.log(str)
}
function debounce1(fn, interval = 300) {
    let timeout = null;
    return function () {
        clearTimeout(timeout);
        timeout = setTimeout(() => {
            fn.apply(this, arguments);
        }, interval);
    };
}
function debounce2(fn, delay = 200) {
    let timeout;
    return function() {
        timeout && clearTimeout(timeout);
        timeout = setTimeout(fn.bind(this), delay, ...arguments);
    }
}
const fn1=debounce1(log,300)
const fn2=debounce2(log,300)
function test(){
    fn1('sss')
    fn2('sss')
}

function throttle(fn, delay) {
    let previous = 0;
    // 使用闭包返回一个函数并且用到闭包函数外面的变量previous
    return function() {
        let args = arguments;
        let now = new Date();
        if(now - previous > delay) {
            fn.apply(this, args);
            previous = now;
        }
    }
}