函数式编程与柯里化

柯里化

在计算机科学中，柯里化是把接受多个参数的函数变换成接受单一参数的函数，并且返回接受余下的参数且返回结果的新函数的技术

函数式编程

• 主要目标是描述数据，以及要对数据应用的转换
• 程序执行的顺序重要性很低（命令式编程中非常重要）
• 函数和数据集合是函数式编程的核心
• 可以使用和滥用函数和递归（命令式编程中使用循环、赋值、条件、函数）
• 要避免副作用和可变数据，所以不会修改传入函数的数据，返回值为源数据的副本

js 函数式编程工具：map、filter、reduce js 中，柯里化用处相对较小，因为 js 的灵活性

示例

普通的 add 函数

function add(x, y) {
    return x + y;
}
add(1, 2);

柯里化后

function curryingAdd(x) {
    return function (y) {
        return x + y;
    };
}
curryingAdd(1)(2);

实际上就是把 add 函数的两个参数变成了先用一个函数接受 x，然后返回另一个函数去处理 y 内外函数处理不同的参数

柯里化好处

参数复用

正常正则验证字符串 reg.test(txt)，函数封装后

function check(reg, txt) {
    return reg.test(txt);
}
check(/\d+/g, 'test'); // false;
check(/[a-z]+/g, 'test'); // true;

Currying 后

function curryingCheck(reg) {
    return function (txt) {
        return reg.test(txt);
    };
}
let hasNumber = curryingCheck(/\d+/g);
let hasLetter = curryingCheck(/[a-z]+/g);
hasNumber('test1'); // true;
hasNumber('testtest'); // false;
hasLetter('21212'); // false;

当有多个地方都要校验，其实就是需要将第一个参数 reg 进行复用，这样别的地方就能够直接调用新函数

提前确认

提前确定了走哪个方法，避免每次都进行判断

let on = (function (isSupport, element, event, handler) {
    isSupport = isSupport || document.addEventListener;
    if (isSupport) {
        return element.addEventListener(event, handler, false);
    } else {
        return element.attachEvent('on' + event, handler);
    }
})();

延迟运行

js 中的 bind，实现的机制就是柯里化的延迟执行，与 call 和 apply 直接执行并改变不同

Function.prototype.bind = function (context) {
    let _this = this;
    let args = Array.prototype.slice.call(arguments, 1);
    return function () {
        return _this.apply(context, args);
    };
};

通用封装方法

function progressCurrying(fn, args) {
    let _this = this;
    let len = fn.length;
    let args = args || [];
    return function () {
        let _args = Array.prototype.slice.call(arguments);
        Array.prototype.push.apply(args, _args);
        // 如果参数个数小于最初的 fn.length，则递归调用，继续收集参数
        if (_args.length < len) {
            return progressCurrying.call(_this, fn, _args);
        }
        // 参数收集完毕，执行 fn
        return fn.apply(this, _args);
    };
}

柯里化性能

• 存取 arguments 对象通常比存取命名参数慢一点
• 一些老版本的浏览器在 arguments.length 的实现上是非常慢的
• fn.apply 和 fn.call 比直接调用 fn 慢
• 创建大量嵌套作用域和闭包函数会带来花销，无论在内存还是速度（在大部分应用中，主要性能瓶颈在操作 DOM 节点上，js 的性能损耗基本可以忽略不计）

实现一个 add 方法，使计算结果满足如下预期

• add(1)(2)(3) = 6;
• add(1, 2, 3)(4) = 10;
• add(1)(2)(3)(4)(5) = 15;

function add() {
    // 第一次执行时，定义一个数组专门用来存储所有的参数
    let _args = Array.prototype.slice.call(arguments);
    // 在内部声明一个函数，利用闭包的特性保存 _args 并收集所有的参数值
    let _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).toString();
add(1, 2, 3)(4).toString();