js高级篇-函数防抖，节流，柯里化(一看就懂)

#1.js的实际开发中，经常需要解决一些问题，比如:在输入框中判断用户输入是否合理? (利用函数防抖思想)

    一般来说，在验证表单中我们会写一个监听函数用来监听用户的输入是否合理，需要判断用户的每一次输入，但是每次输入都要进行触发监听事件,会太频繁，我们大多时候只希望用户输入完毕进行一次判断就可以了。
    解决办法: setTimeout,根据输入延迟时间进行判断，如果输入间隔小于函数延时时间，就清除上一次的执行
   函数防抖，
   为了防止函数连续触发，保证仅仅触发最后一次即可
   function debounce(fn,time){           //fn，要执行的函数，time ,延时执行时间
    let timeOut;                        //定义执行时间
    return function()
    {
    ClearTimeOut(timeOut)//           //清除上一次的执行
    timeOut= setTimeOut(()=>{
    fn.apply( )
    },time)
    }
  }

#2.鼠标移动时触发事件(利用函数节流思想，在规定时间内只执行一次操作)

	  function throttle(fn,time)  {  
			  let key=turn;             //设置开关
			    if(!key)
			    {return;}
			    Key=false;               //开关关闭
			    setTimeOut(()=>{
			   this,fn();                 //执行传入执行的函数
			   key=true;
    },time)                  //传入的延时时间
  }

#3.柯里化,可能你没有经常听到这个名字，不过我相信你一定在js中见过，js中.bind(),vue中使用axios网络请求时使用.bind(this),绑定this对象

  先说说柯里化的优点
  1. 参数复用
  2. 提前确认
  3. 延迟执行
  4. // 初步封装(参考网上代码)
		      var currying = function(fn) {
		    // args 获取第一个方法内的全部参数
		    var args = Array.prototype.slice.call(arguments, 1)
		    return function() {
		        // 将后面方法里的全部参数和args进行合并
		        var newArgs = args.concat(Array.prototype.slice.call(arguments))
		        // 把合并后的参数通过apply作为fn的参数并执行
		        return fn.apply(this, newArgs)
		     }
		    }
5.  // 支持多参数传递(参考网上代码)
					function progress(fn, args) {
					    var that = this             //指针指向
					    var len = fn.length;     //传进来函数的长度
					    var _args = args || [];  
					    return function() {
					        var _args = Array.prototype.slice.call(arguments);
					        Array.prototype.push.apply(args, _args);
					        // 如果参数个数小于最初的fn.length，就递归调用，继续收集参数
					        if (_args.length < len) {
					            return progressCurrying.call(that , fn, _args);
					        }
					        // 参数收集完毕，则执行fn
					        return fn.apply(this,_args);
					    }
					    }
 6.实现柯里化代码封装: （leecode中的一道题进行举例）(参考网上代码)
// 实现一个add方法，使计算结果能够满足如下预期：
add(1)(2)(3) = 6;
add(1, 2, 3)(4) = 10;
add(1)(2)(3)(4)(5) = 15;
function add() {
// 第一次执行时，定义一个数组专门用来存储所有的参数
var _args = Array.prototype.slice.call(arguments);
// 在内部声明一个函数，利用闭包的特性保存_args并收集所有的参数值
var _adder = function() {
    _args.push(...arguments);
    return _adder;
};
// 利用toString隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
_adder.toString = function () {
    return _args.reduce(function (a, b) {
        return a + b;
    });
}
return _adder;
}
add(1)(2)(3)                // 6
add(1, 2, 3)(4)             // 10
add(1)(2)(3)(4)(5)          // 15
add(2, 6)(1)                // 9

#4.以上即是本人对js防抖，节流，柯里化的全部理解,如果对你有帮助，请点赞+关注+收藏 (如果有误，请留言指出，会及时修改)