js 函数式编程之函数柯里化

2019年8月27日 154次阅读 来源: honger05

函数柯里化是指参数逐步求值的历程。

我以为它是：下降通用性，进步专用性。

一般，柯里化是如许的历程，“假如你牢固某些参数，你将获得接收余下参数的一个函数”。所以关于有两个变量的函数y^x，假如牢固了 y=2，则获得有一个变量的函数 2^x

通用完成

function currying(fn) {
  var slice = Array.prototype.slice;
    var args = alice.call(arguments, 1);
    return function() {
    var innerArgs = slice.call(arguments);
    var finalArgs = args.concat(innerArgs);
    return fn.apply(null, finalArgs);
  }
}

先看一个简朴的例子

function add(num1, num2) {
    return num1 + num2;
}

function curryAdd(num) {
    return num + 5;
}

add(2, 4); // 6
curryAdd(1); // 6

curryAdd 明显不是一个柯里化的完成。然则它很好的解释了柯里化的头脑。add 函数有两个参数，curryAdd 牢固了个中一个参数

用上面 currying 函数组织 curryAdd 函数。

var curryAdd5 = currying(add, 5);

var curryAdd4 = currying(add, 4);

curryAdd5(1); // 6

curryAdd4(1); // 5

再看一个典范的 ajax 例子。

function Ajax() {
    this.xhr = new XMLHttpRequest();
}

Ajax.prototype.open = function(type, url, data, callback) {
    this.onload = function() {
    callback(this.xhr.responseText, this.xhr.status, thix.xhr);
  }

  this.xhr.open(type, url, data.async);
  this.xhr.send(data.paras);
}

['get', 'post'].forEach(function(type) {
    Ajax.prototype[type] = currying(Ajax.prototype.open, type);
})

var xhr = new Ajax();

xhr.get('/articles/list', {}, function(datas) {});

xhr.post('/articles/add', {}, function(datas) {});

get post 两个要领是经由过程 ‘open’ 要领衍生出来的。

从一个通用的 open 函数（可接收恣意type），柯里化成专用的函数 get、post。

牢固易变因数

提早把易变因数牢固下来，天生一个更明白的运用函数，最典范的代码就是 ES5 定义的 Function.prototype.bing 函数

Function.prototype.bing = function(context) {
    var _this = this,
        slice = Array.prototype.slice,
        _args = slice.call(arguments, 1);

    return function() {
        return _this.apply(context, _args.concat(slice.call(arguments)))
    }
}

耽误实行

不停的柯里化，积累传入的参数，末了实行。

function add() {
  var sum = 0, i, len;
    for (i = 0, len = arguments.length; i < len; i++) {
    sum += arguments[i];
  }
  return sum;
}

var currying = function(fn) {
    var _args = [];

    return function cb() {
        if (arguments.length === 0) {
            return fn.apply(this, _args);
        }

        Array.prototype.push.apply(_args, arguments);

        return cb;
    }
}

var curryingAdd = currying(add);

curryingAdd(1)(2)(3)(4)(); // 10

var add321 = curryingAdd(3)(2, 1);

add321(4)(); // 10

机能

柯里化一定会有一些开支（函数嵌套，比一般函数占更多内存），但机能瓶颈起首来自别的缘由（DOM 操纵等）。

从别的一个角度剖析，不论你用不用柯里化这个头脑，你的代码极可能已步入了更庞杂的形式，会有更大的开支。

有关机能的一些事：

  • 存取 arguments 对象一般要比存取定名参数要慢一些。

  • 一些老版本的浏览器在 arguments.length 的完成上相称慢。

  • 运用 fn.apply() 和 fn.call() 要比直接挪用 fn() 要慢点。

  • 建立大批嵌套作用域和闭包会带来开支，无论是内容照样速度上。

  • 大多数瓶颈来自 DOM 操纵

总结

柯里化是以逻辑学家哈斯凯尔·加里定名的，

正如它的定名一样，函数柯里化给我们带来的是：解决问题的一种逻辑头脑体式格局。

    原文作者：honger05
    原文地址: https://segmentfault.com/a/1190000003733107
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞