函数防抖和节流

防抖

应用场景:比如input输入事件，要实时展示搜索结果。每次change事件都会发送一次请求，仅从资源上来说是很浪费的行为，而且在实际应用中，也是用户输入完毕之后才会请求展示搜索结果。所以加用防抖或者节流函数包括一下。

function dedounce(func, delay = 500) {
  let timer = null;
  return function (...args) {
      if(timer){
        clearTimeout(timer);
        timer = null;
      }
    timer = setTimeout(
        () => {
          func.apply(this,args)
        },
    delay
    )
  }
}
//更加简洁
function dedounce(method, context) {
      clearTimeout(method.tId);
      method.tId = setTimeout(function () {
          method.call(context);
      }, 100)
  }

节流

返回的函数在一段时间内只会执行一次，比如用在滚动事件的回调。

function th(func, delay = 2000) {
  let now = new Date().getTime();
  return function () {
    let newNow = new Date().getTime();
    if (newNow - now > delay) {
      now = newNow;
      func.apply(this, arguments);
    }
  }
}

函数防抖和函数节流都是防止某一时间频繁触发，但是这两兄弟之间的原理却不一样。
函数防抖是某一段时间内只执行一次，而函数节流是间隔时间执行。

函数柯里化

// 第一版
//利用slice 加回调的方式。但是回调的参数没法导正

var curry = function (fn) {
    var args = [].slice.call(arguments, 1);
    return function() {
        var newArgs = args.concat([].slice.call(arguments));
        return fn.apply(this, newArgs);
    };
};

//利用toString的特性，但是不好看
    function add() {
            // 第一次执行时，定义一个数组专门用来存储所有的参数
            let args = [].slice.call(arguments);

            // 在内部声明一个函数，利用闭包的特性保存_args并收集所有的参数值
            var inner = function () {
                args.push(...arguments);
                return inner;
            };

            // 利用toString隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
            inner.toString = () => args.reduce((prev, curr) => prev + curr);
            return inner;
        }

JavaScript

函数节流防抖，柯里化

函数防抖和节流

函数柯里化