高阶函数、函数柯里化、封装柯里化函数

高阶函数

        function test(a, b, fn) {
            return fn(a) + fn(b);
        }
        function square(x) {
            return Math.pow(x, 2);
        }
        console.log(test(2, 3, square)); //13
        function test2(a, b, pow) {
            return pow(a, 2) + pow(b, 2);
        }
        function pow(x, n) {
            return Math.pow(x, n);
        }
        var res = test2(2, 3, pow);
        console.log(res); //13

JS函数实际上都是指向某一个变量 无论是函数表达式 还是函数声明的形式
var test = function (a,b) { }
function test() { }

    test -> 一个函数<br />        函数参数 -> 接收变量<br />        函数的参数能接收变量<br />        一个函数就可以接收另一个函数作为变量

    **一个函数接收另一个函数作为参数变量的这个函数就是高阶函数**

demo

        // map() -> 数据处理函数 -> 高阶函数
        // reduce() -> 归纳函数 -> 高阶函数

        var arr = [1, 2, 3, 4, 5];
        function addOne(elem) {
            return elem + 1;
        }
        var newArr = arr.map(addOne);

        function setData(initVal, elem) {
            if (elem > 3) {
                initVal.push(elem);
            }
            return initVal;
        }
        var newArr = arr.reduce(setData, []);
        console.log(newArr);

高阶函数
数组的扩展方法
计时器
sort
replace

        var test = function (fn) {
            return doSth(function (data) {
                return fn(data);
            });
        }

        function doSth(fn) {
            fn();
        }

        // fn(data) -> function (data) {return fn(data)}()

        // var test = function (fn) {
        //     return doSth(fn(data));
        // }

        // var test = function (fn) {
        //     fn(data);
        // }
        var test = fn(data);

柯里化 函数式编程的思想

    在计算机科学中,柯里化把接收多个参数的函数编程接受一个单一的参数（最初函数的第一个参数）的函数，并且返回接收余下的参数且返回结果的新函数的技术

1、简化代码
2、提高维护性
3、功能单一化

    功能内聚<br />        降低耦合<br />        降低代码的重复性<br />        提高代码的适应性

        function curry(fn, len) {
            var len = len || fn.length;
            var func = function (fn) {
                var _arg = [].slice.call(arguments, 1);
                return function () {
                    var newArgs = _arg.concat([].slice.call(arguments));
                    return fn.apply(this, newArgs);
                }
            }
            return function () {
                var argLen = arguments.length;
                if (argLen < len) {
                    var formatedArr = [fn].concat([].slice.call(arguments));
                    return curry(func.apply(this, formatedArr), len - argLen);
                }
                else {
                    return fn.apply(this, arguments);
                }
            }
        }
            //demo1
        function add(a, b, c, d) {
            return a + b + c + d;
        }
        var add2 = curry(add);

        var res = add2(1)(2)(3)(4); //10
        //demo2
                function ajaxRequest(opt, data, sCB, eCB) {
            $.ajax({
                url: opt.url,
                type: opt.type,
                dataType: opt.dataType,
                data: data,
                success: sCB,
                error: eCB
            });
        }
        var $ajax = curry(ajaxRequest);
        var ajaxApi = {
            getCourses: $ajax({
                url: 'http://study.jsplusplus.com/Index/getCourses',
                type: 'POST',
                dataType: 'JSON'
            })
        }
        ajaxApi.getCourses({
            page: 1,
        })
            (function (data) {
                console.log(data);
            })
            (function () {
                console.log('ERROR');
            })