柯里化

ES6实现

function curry (fn) {
    const ctx = this
    function inner (...args) {
        if(args.length === fn.length) return fn.call(ctx, ...args)
        return (...innerags) => {
            return inner.call(ctx, ...args, ...innerags)
        }
    }
    return inner
}
var add = function(a,b,c){
    console.log(a+ b + c)
}
var f = curry(add)
f(1,2)(2)

柯里化

function curry (fn, currArgs) {
    //fn 最初的函数sum
    //arguments [fn, currArgs]
    //currArgs 闭包保存currArgs 首次没有
    return function() {
        let args = [].slice.call(arguments)
        //args, arguments 返回函数传入的新参数
        if (currArgs !== undefined) {
            args = args.concat(currArgs)
            //之前有arg的合上
        }
        // 递归调用
        if (args.length < fn.length) {
            //传入当前所有参数args递归
            //args与currArgs一致呼应
            return curry(fn, args)
        }
        //参数达到要求sum要求了执行
        return fn.apply(null, args)
    }
}

function sum(a, b, c) {
    console.log(a + b + c)
}
const fn = curry(sum)

fn(1, 2)

在一个函数中首先填充几个参数，然后再返回一个新函数的技术称为柯里化(Currying)。

两个变量的函数y，x，固定了y=2，则得到一个变量的函数2，x。部分求值策略。

柯里化(Currying)具有：延迟计算、参数复用、动态生成函数的作用。

柯里化的应用

柯里化不同于的闭包在于柯里化返回的函数还带有参数

事件监听

每调用一次函数都需要重新进行判断

var addEvent = function(ele, type, fn){
    if(window.addEventListener){
        ele.addEventListener(type, fn)
    } else if(window.attachEvent){
        ele.attachEvent('on' + type, fn)
    }
}

让判断只执行一次

var addEvent = (function(){
    if(window.addEventListener){
        return function(ele, type, fn){
            ele.addEventListener(type, fn)
        }
    } else if(window.attachEvent){
        return function(ele, type, fn){
            ele.attachEvent('on' + type, fn)
        }
    }
})()

手动实现bind

Function.prototype.myBind = function(context, ...args){
    return (...innerArgs) => {
        this.call(context, ...args, ...innerArgs)
    }
}

防抖节流

https://www.jianshu.com/p/862e87832a06