偏函数、偏函数与柯里函数的区别、惰性函数

函数的元：参数个数
有两个参数的函数 二元函数

在计算机科学中，偏函数叫做部分应用 局部应用，指固定一个函数的一些参数 然后产生另一个更小元(参数个数)的函数

柯里化：

将一个多参数的函数转成多个单参数的函数
将n元函数转换成n个一元函数
例如：newFn(1)(2)(3)(4)

偏函数：

是固定一个函数的一个或多个参数 将n元函数转换成n-x元函数 (ps:先传一些参数、然后二次再传一些参数

封装偏函数方法

        function add(a, b, c, d) {
            return a + b + c + d;
        }
        Function.prototype.partial = function () {
            var _self = this,
                _args = [].slice.call(arguments);
            return function () {
                var newArgs = _args.concat([].slice.call(arguments));
                return _self.apply(null, newArgs); 
              //立即执行这个函数方法参数是数组所以用apply
            }
        }
        var newAdd = add.partial(1, 2);
        console.log(newAdd(3, 4)); //10
             function formatSentence(time, opt) {
            return time + ' ' + opt.user_class + ' ' + opt.name + '：' + opt.sentence;
        }
        var outPutSentence = formatSentence.partial(new Date().getHours() + ':' + new Date().getMinutes());
        console.log(outPutSentence({
            user_class: '管理员',
            name: '小野',
            sentence: '欢迎大家加入JS++'
        })); //10:19 管理员 小野：欢迎大家加入JS++

惰性函数

惰性加载表示函数执行的分支只会在函数第一次调用的时候执行，
在第一次调用的过程中，该函数被覆盖为另一个按照合适的方式执行的函数
这样任何对原函数的调用就不用再经过执行的分支了.

例如

        function test(num) {
            switch (num) {
                case 1:
                    test = function () {
                        console.log('我爱你');
                    }
                    break;
                case 2:
                    test = function () {
                        console.log('我喜欢你');
                    }
                    break;
                case 3:
                    test = function () {
                        console.log('我讨厌你');
                    }
                    break;
            }
            return test();
        }
        test(2); //我喜欢你
        test(3); //我喜欢你

        var getTimeStamp = function () {
            var timeStamp = new Date().getTime();
            console.log(1);

            getTimeStamp = function () {
                return timeStamp;
            }
            return getTimeStamp();
        }

        console.log(getTimeStamp());
        console.log(getTimeStamp());
        console.log(getTimeStamp());
        console.log(getTimeStamp());

 //1
 //1624588740040
 //1624588740040
 //1624588740040
 //1624588740040

惰性函数重写addEvent

        var addEvent = (function () {
            if (window.addEventListener) {
                return function (el, type, fn, capture) {
                    el.addEventListener(type, fn, capture);
                }
            } else if (window.attachEvent) {
                return function (el, type, fn) {
                    el.attachEvent('on' + type, function () {
                        fn.call(el);
                    });
                }
            } else {
                return function (el, type, fn) {
                    el['on' + type] = fn;
                }
            }
        })();

        var addEvent = (function () {
            if (window.addEventListener) {
                addEvent= (el, type, fn, capture) {
                    el.addEventListener(type, fn, capture);
                }
            } else if (window.attachEvent) {
                addEvent= (el, type, fn) {
                    el.attachEvent('on' + type, function () {
                        fn.call(el);
                    });
                }
            } else {
                addEvent= (el, type, fn) {
                    el['on' + type] = fn;
                }
            }
        })();

        function addEvent(el, type, fn, capture) {
            if (el.addEventListener) {
                addEvent = (el, type, fn, capture) {
                    el.addEventListener(type, fn, capture);
                }
            } else if (el.attachEvent) {
                addEvent = (el, type, fn) {
                    el.attachEvent('on' + type, function () {
                        fn.call(el);
                    });
                }
            } else {
                addEvent = (el, type, fn) {
                    el['on' + type] = fn;
                }
            }
        }