Visitar URL original
JavaScript专题之函数柯里化 · Issue #42 · mqyqingfeng/Blog · GitHub
Skip to content

JavaScript专题之函数柯里化 #42

Open
Open
JavaScript专题之函数柯里化#42
Labels
专题系列

Description

@mqyqingfeng
mqyqingfeng
opened on Aug 11, 2017

定义

维基百科中对柯里化 (Currying) 的定义为：

In mathematics and computer science, currying is the technique of translating the evaluation of a function that takes multiple arguments (or a tuple of arguments) into evaluating a sequence of functions, each with a single argument.

翻译成中文：

在数学和计算机科学中，柯里化是一种将使用多个参数的一个函数转换成一系列使用一个参数的函数的技术。

举个例子：

function add(a, b) {
    return a + b;
}

// 执行 add 函数，一次传入两个参数即可
add(1, 2) // 3

// 假设有一个 curry 函数可以做到柯里化
var addCurry = curry(add);
addCurry(1)(2) // 3

用途

我们会讲到如何写出这个 curry 函数，并且会将这个 curry 函数写的很强大，但是在编写之前，我们需要知道柯里化到底有什么用？

举个例子：

// 示意而已
function ajax(type, url, data) {
    var xhr = new XMLHttpRequest();
    xhr.open(type, url, true);
    xhr.send(data);
}

// 虽然 ajax 这个函数非常通用，但在重复调用的时候参数冗余
ajax('POST', 'www.test.com', "name=kevin")
ajax('POST', 'www.test2.com', "name=kevin")
ajax('POST', 'www.test3.com', "name=kevin")

// 利用 curry
var ajaxCurry = curry(ajax);

// 以 POST 类型请求数据
var post = ajaxCurry('POST');
post('www.test.com', "name=kevin");

// 以 POST 类型请求来自于 www.test.com 的数据
var postFromTest = post('www.test.com');
postFromTest("name=kevin");

想想 jQuery 虽然有 $.ajax 这样通用的方法，但是也有 $.get 和 $.post 的语法糖。(当然 jQuery 底层是否是这样做的，我就没有研究了)。

curry 的这种用途可以理解为：参数复用。本质上是降低通用性，提高适用性。

可是即便如此，是不是依然感觉没什么用呢？

如果我们仅仅是把参数一个一个传进去，意义可能不大，但是如果我们是把柯里化后的函数传给其他函数比如 map 呢？

举个例子：

比如我们有这样一段数据：

var person = [{name: 'kevin'}, {name: 'daisy'}]

如果我们要获取所有的 name 值，我们可以这样做：

var name = person.map(function (item) {
    return item.name;
})

不过如果我们有 curry 函数：

var prop = curry(function (key, obj) {
    return obj[key]
});

var name = person.map(prop('name'))

我们为了获取 name 属性还要再编写一个 prop 函数，是不是又麻烦了些？

但是要注意，prop 函数编写一次后，以后可以多次使用，实际上代码从原本的三行精简成了一行，而且你看代码是不是更加易懂了？

person.map(prop('name')) 就好像直白的告诉你：person 对象遍历(map)获取(prop) name 属性。

是不是感觉有点意思了呢？

第一版

未来我们会接触到更多有关柯里化的应用，不过那是未来的事情了，现在我们该编写这个 curry 函数了。

一个经常会看到的 curry 函数的实现为：

// 第一版
var curry = function (fn) {
    var args = [].slice.call(arguments, 1);
    return function() {
        var newArgs = args.concat([].slice.call(arguments));
        return fn.apply(this, newArgs);
    };
};

我们可以这样使用：

function add(a, b) {
    return a + b;
}

var addCurry = curry(add, 1, 2);
addCurry() // 3
//或者
var addCurry = curry(add, 1);
addCurry(2) // 3
//或者
var addCurry = curry(add);
addCurry(1, 2) // 3

已经有柯里化的感觉了，但是还没有达到要求，不过我们可以把这个函数用作辅助函数，帮助我们写真正的 curry 函数。

第二版

// 第二版
function sub_curry(fn) {
    var args = [].slice.call(arguments, 1);
    return function() {
        return fn.apply(this, args.concat([].slice.call(arguments)));
    };
}

function curry(fn, length) {

    length = length || fn.length;

    var slice = Array.prototype.slice;

    return function() {
        if (arguments.length < length) {
            var combined = [fn].concat(slice.call(arguments));
            return curry(sub_curry.apply(this, combined), length - arguments.length);
        } else {
            return fn.apply(this, arguments);
        }
    };
}

我们验证下这个函数：

var fn = curry(function(a, b, c) {
    return [a, b, c];
});

fn("a", "b", "c") // ["a", "b", "c"]
fn("a", "b")("c") // ["a", "b", "c"]
fn("a")("b")("c") // ["a", "b", "c"]
fn("a")("b", "c") // ["a", "b", "c"]

效果已经达到我们的预期，然而这个 curry 函数的实现好难理解呐……

为了让大家更好的理解这个 curry 函数，我给大家写个极简版的代码：

function sub_curry(fn){
    return function(){
        return fn()
    }
}

function curry(fn, length){
    length = length || 4;
    return function(){
        if (length > 1) {
            return curry(sub_curry(fn), --length)
        }
        else {
            return fn()
        }
    }
}

var fn0 = function(){
    console.log(1)
}

var fn1 = curry(fn0)

fn1()()()() // 1

大家先从理解这个 curry 函数开始。

当执行 fn1() 时，函数返回：

curry(sub_curry(fn0))
// 相当于
curry(function(){
    return fn0()
})

当执行 fn1()() 时，函数返回：

curry(sub_curry(function(){
    return fn0()
}))
// 相当于
curry(function(){
    return (function(){
        return fn0()
    })()
})
// 相当于
curry(function(){
    return fn0()
})

当执行 fn1()()() 时，函数返回：

// 跟 fn1()() 的分析过程一样
curry(function(){
    return fn0()
})

当执行 fn1()()()() 时，因为此时 length > 2 为 false，所以执行 fn()：

fn()
// 相当于
(function(){
    return fn0()
})()
// 相当于
fn0()
// 执行 fn0 函数，打印 1

再回到真正的 curry 函数，我们以下面的例子为例：

var fn0 = function(a, b, c, d) {
    return [a, b, c, d];
}

var fn1 = curry(fn0);

fn1("a", "b")("c")("d")

当执行 fn1("a", "b") 时：

fn1("a", "b")
// 相当于
curry(fn0)("a", "b")
// 相当于
curry(sub_curry(fn0, "a", "b"))
// 相当于
// 注意 ... 只是一个示意，表示该函数执行时传入的参数会作为 fn0 后面的参数传入
curry(function(...){
    return fn0("a", "b", ...)
})

当执行 fn1("a", "b")("c") 时，函数返回：

curry(sub_curry(function(...){
    return fn0("a", "b", ...)
}), "c")
// 相当于
curry(function(...){
    return (function(...) {return fn0("a", "b", ...)})("c")
})
// 相当于
curry(function(...){
     return fn0("a", "b", "c", ...)
})

当执行 fn1("a", "b")("c")("d") 时，此时 arguments.length < length 为 false ，执行 fn(arguments)，相当于：

(function(...){
    return fn0("a", "b", "c", ...)
})("d")
// 相当于
fn0("a", "b", "c", "d")

函数执行结束。

所以，其实整段代码又很好理解：

sub_curry 的作用就是用函数包裹原函数，然后给原函数传入之前的参数，当执行 fn0(...)(...) 的时候，执行包裹函数，返回原函数，然后再调用 sub_curry 再包裹原函数，然后将新的参数混合旧的参数再传入原函数，直到函数参数的数目达到要求为止。

如果要明白 curry 函数的运行原理，大家还是要动手写一遍，尝试着分析执行步骤。

更易懂的实现

当然了，如果你觉得还是无法理解，你可以选择下面这种实现方式，可以实现同样的效果：

function curry(fn, args) {
    var length = fn.length;

    args = args || [];

    return function() {

        var _args = args.slice(0),

            arg, i;

        for (i = 0; i < arguments.length; i++) {

            arg = arguments[i];

            _args.push(arg);

        }
        if (_args.length < length) {
            return curry.call(this, fn, _args);
        }
        else {
            return fn.apply(this, _args);
        }
    }
}


var fn = curry(function(a, b, c) {
    console.log([a, b, c]);
});

fn("a", "b", "c") // ["a", "b", "c"]
fn("a", "b")("c") // ["a", "b", "c"]
fn("a")("b")("c") // ["a", "b", "c"]
fn("a")("b", "c") // ["a", "b", "c"]

或许大家觉得这种方式更好理解，又能实现一样的效果，为什么不直接就讲这种呢？

因为想给大家介绍各种实现的方法嘛，不能因为难以理解就不给大家介绍呐~

第三版

curry 函数写到这里其实已经很完善了，但是注意这个函数的传参顺序必须是从左到右，根据形参的顺序依次传入，如果我不想根据这个顺序传呢？

我们可以创建一个占位符，比如这样：

var fn = curry(function(a, b, c) {
    console.log([a, b, c]);
});

fn("a", _, "c")("b") // ["a", "b", "c"]

我们直接看第三版的代码：

// 第三版
function curry(fn, args, holes) {
    length = fn.length;

    args = args || [];

    holes = holes || [];

    return function() {

        var _args = args.slice(0),
            _holes = holes.slice(0),
            argsLen = args.length,
            holesLen = holes.length,
            arg, i, index = 0;

        for (i = 0; i < arguments.length; i++) {
            arg = arguments[i];
            // 处理类似 fn(1, _, _, 4)(_, 3) 这种情况，index 需要指向 holes 正确的下标
            if (arg === _ && holesLen) {
                index++
                if (index > holesLen) {
                    _args.push(arg);
                    _holes.push(argsLen - 1 + index - holesLen)
                }
            }
            // 处理类似 fn(1)(_) 这种情况
            else if (arg === _) {
                _args.push(arg);
                _holes.push(argsLen + i);
            }
            // 处理类似 fn(_, 2)(1) 这种情况
            else if (holesLen) {
                // fn(_, 2)(_, 3)
                if (index >= holesLen) {
                    _args.push(arg);
                }
                // fn(_, 2)(1) 用参数 1 替换占位符
                else {
                    _args.splice(_holes[index], 1, arg);
                    _holes.splice(index, 1)
                }
            }
            else {
                _args.push(arg);
            }

        }
        if (_holes.length || _args.length < length) {
            return curry.call(this, fn, _args, _holes);
        }
        else {
            return fn.apply(this, _args);
        }
    }
}

var _ = {};

var fn = curry(function(a, b, c, d, e) {
    console.log([a, b, c, d, e]);
});

// 验证 输出全部都是 [1, 2, 3, 4, 5]
fn(1, 2, 3, 4, 5);
fn(_, 2, 3, 4, 5)(1);
fn(1, _, 3, 4, 5)(2);
fn(1, _, 3)(_, 4)(2)(5);
fn(1, _, _, 4)(_, 3)(2)(5);
fn(_, 2)(_, _, 4)(1)(3)(5)

写在最后

至此，我们已经实现了一个强大的 curry 函数，可是这个 curry 函数符合柯里化的定义吗？柯里化可是将一个多参数的函数转换成多个单参数的函数，但是现在我们不仅可以传入一个参数，还可以一次传入两个参数，甚至更多参数……这看起来更像一个柯里化 (curry) 和偏函数 (partial application) 的综合应用，可是什么又是偏函数呢？下篇文章会讲到。

专题系列

JavaScript专题系列目录地址：https://github.com/mqyqingfeng/Blog。

JavaScript专题系列预计写二十篇左右，主要研究日常开发中一些功能点的实现，比如防抖、节流、去重、类型判断、拷贝、最值、扁平、柯里、递归、乱序、排序等，特点是研(chao)究(xi) underscore 和 jQuery 的实现方式。

如果有错误或者不严谨的地方，请务必给予指正，十分感谢。如果喜欢或者有所启发，欢迎 star，对作者也是一种鼓励。

Activity

  1. mqyqingfeng
    added
    专题系列
    on Aug 11, 2017

  2. liuxinqiong commented on Aug 18, 2017

    @liuxinqiong
    liuxinqiong
    on Aug 18, 2017

    日常学习

  3. FrontToEnd commented on Aug 22, 2017

    @FrontToEnd
    FrontToEnd
    on Aug 22, 2017

    好难理解啊☹️

  4. mqyqingfeng commented on Aug 22, 2017

    @mqyqingfeng
    mqyqingfeng
    on Aug 22, 2017
    OwnerAuthor

    segmentfault 的@大笑平 补充的高颜值写法：

    var curry = fn =>
    judge = (...args) =>
        args.length === fn.length
            ? fn(...args)
            : (arg) => judge(...args, arg)

  5. jawil commented on Aug 22, 2017

    @jawil
    jawil
    on Aug 22, 2017

    专题系列专不知不觉更新了这么多，我得好好抽个时间系统学习一下😂

  6. mqyqingfeng commented on Aug 22, 2017

    @mqyqingfeng
    mqyqingfeng
    on Aug 22, 2017
    OwnerAuthor

    @jawil 哈哈~ 还有五篇就要完结了，可以等完结后一起看~

  7. yangchongduo commented on Oct 10, 2017

    @yangchongduo
    yangchongduo
    on Oct 10, 2017

    没有说道 什么场景下使用 柯里化

  8. yangchongduo commented on Oct 10, 2017

    @yangchongduo
    yangchongduo
    on Oct 10, 2017
    var name = person.map(function (item) {
    return item.name;
})
const fn = function (item) {
    return item.name;
}
person.map(fn)

    PS：这样也可以参数复用

  9. mqyqingfeng commented on Oct 11, 2017

    @mqyqingfeng
    mqyqingfeng
    on Oct 11, 2017
    OwnerAuthor

    @yangchongduo 柯里化的应用更多在函数式编程中，可以看 JS 函数式编程指南，在 《JavaScript专题之函数组合》这篇文章中也有涉及部分。

  10. mqyqingfeng commented on Oct 11, 2017

    @mqyqingfeng
    mqyqingfeng
    on Oct 11, 2017
    OwnerAuthor

    @yangchongduo 这样确实可以做到参数复用，其实跟

    var name = person.map(prop('name'))

    是一样的，不过如果我们要获得其他属性呢？比如 'age'、'friends' 等，如果使用 fn 的话，还需要写多个 fn，而如果使用 prop 函数，就可以直接使用 prop('age') prop('friend')

  11. heyunjiang commented on Oct 11, 2017

    @heyunjiang
    heyunjiang
    on Oct 11, 2017

    高颜值写法的 judge = (...args) 用的好巧妙

  12. yangchongduo commented on Oct 19, 2017

    @yangchongduo
    yangchongduo
    on Oct 19, 2017

    function curry1(fn, args) {
    var length = fn.length;
    args = args || [];
    return function (...arguments) {
    args = [...args, ...arguments]
    return args.length < length ? curry1.call(this, fn, args) : fn.apply(this, args);
    }
    }

  13. LiuYashion commented on Oct 31, 2017

    @LiuYashion
    LiuYashion
    on Oct 31, 2017

    值得一看~

  14. hlmjack commented on Oct 31, 2017

    @hlmjack
    hlmjack
    on Oct 31, 2017

    深受启发，这样理解柯里化 ：用闭包把参数保存起来，当参数的数量足够执行函数了，就开始执行函数，有没有毛病

  15. mqyqingfeng commented on Oct 31, 2017

    @mqyqingfeng
    mqyqingfeng
    on Oct 31, 2017
    OwnerAuthor

    @hlmjack 正是如此~ o(￣▽￣)ｄ

  16. 113 remaining items

  17. fwqaaq commented on Feb 24, 2022

    @fwqaaq
    fwqaaq
    on Feb 24, 2022

    我使用了ts的形式重写了一下没有问题,有问题可以多多交流喔

    function curry<T>(fn: Function): Function {
  return function (...args: T[]) {
    if (args.length < fn.length) {
      return curry(fn.bind(this, ...args))
    } else {
      return fn(...args)
    }
  }
}

type IPerson = {
  name: string
  age: number
}

const person: IPerson[] = [
  { name: "zhangsan", age: 12 },
  { name: "lisi", age: 100 },
]

let prop = curry((key: keyof IPerson, obj: IPerson) => {
  return obj[key]
})

  18. ccBreeze commented on May 14, 2022

    @ccBreeze
    ccBreeze
    on May 14, 2022
    function curry(fn) {
  return function f(...args) {
    return args.length < fn.length
      ? (..._args) => f(...args, ..._args) // 长度不够，等待下一次补齐
      : fn(...args) // 执行函数
  };
}

// call / apply
function curry(fn, args = []) {
  return function () {
    // 将之前的参数，和新传入的参数合并
    const _args = [...args, ...arguments];
    // 参数长度不够，等待下一次调用补齐
    if (_args.length < fn.length) {
      return curry.call(this, fn, _args);
    }
    // 执行函数
    return fn(..._args);
  };
}

  19. chaomingd commented on May 17, 2022

    @chaomingd
    chaomingd
    on May 17, 2022
    function curry (fn) {
  const len = fn.length;
  const args = Array.prototype.slice.call(arguments, 1);
  let context = this;
  function inner () {
    args.push.apply(args, arguments);
    if (args.length > len) {
      throw new Error('curried function with ' + len + ' argument but pass ' + args.length + ' arguments')
    }
    if (args.length === len) {
      return fn.apply(context, args)
    }
    return inner;
  }
  return inner
}

    这样更容易理解

  20. LuMMao commented on May 20, 2022

    @LuMMao
    LuMMao
    on May 20, 2022

    极简版的 curry 分析过程不能按照文中的逻辑。。。我分析了半天都对不上
    fn1() 的返回值应该是：

    fn_1 = function() {
  return fn0();
}
curry(fn_1, --length)
// 也就是
function() {
  if(length > 1) {
    return curry(sub_curry(fn_1), --length)
  }else {
    return fn_1();
  }
}
// 此时的 length 为 3

    fn1()() 的返回值：

    fn_2 = function() {
  return fn_1();
}
function() {
  if(length > 1) {
    return curry(sub_curry(fn_2), --length)
  }else {
    return fn_2();
  }
}
// 此时的 length 为 2

    fn1()()() 的返回值：

    fn_3 = function() {
  return fn_2();
}
function() {
  if(length > 1) {
    return curry(sub_curry(fn_3), --length)
  }else {
    return fn_3();
  }
}
// 此时的 length 为 1

    fn1()()()() 的返回值：

    (function() {
  if(length > 1) {
    return curry(sub_curry(fn_3), --length)
  }else {
    return fn_3();
  }
})()
fn_3()
fn_2()
fn_1()
fn0()
console.log(1)

  21. realheng commented on Jun 17, 2022

    @realheng
    realheng
    on Jun 17, 2022

    fn(1, _, , 4)(, 3)(2)(5)的结果为何不是1,3,2,4,5

  22. begodya commented on Jul 1, 2022

    @begodya
    begodya
    on Jul 1, 2022

    var currying = (fn, ...arg) => (...arg.length >= fn.length ? fn(...arg) : (..._arg) => currying(fn, ...arg, ..._arg))

  23. jbts6 commented on Jul 19, 2022

    @jbts6
    jbts6
    on Jul 19, 2022

    fn(1, _, , 4)(, 3)(2)(5)的结果为何不是1,3,2,4,5

    你是 (_,3) ，3前面还有个占位符，所以2会到3前面

  24. chandq commented on Aug 5, 2022

    @chandq
    chandq
    on Aug 5, 2022

    segmentfault 的@大笑平 补充的高颜值写法：

    var curry = fn =>
    judge = (...args) =>
        args.length === fn.length
            ? fn(...args)
            : (arg) => judge(...args, arg)

    很精简，稍微改下会更强大，

    var curry = fn =>
    judge = (...args) =>
        args.length === fn.length
            ? fn(...args)
            : (...arg) => judge(...args, ...arg)

  25. xiaochengzi6 commented on Aug 30, 2022

    @xiaochengzi6
    xiaochengzi6
    on Aug 30, 2022

    掘金 的这篇文章写出来的代码比较好理解：

    /**
 * @param {*} fn 回调函数
 * @param {*} [length=fn.length] 回调函数所需要参数的数量
 * @param {*} [holder=curry] 占位符
 */
function curry(fn, length = fn.length, holder = curry) {
  return _curry.call(this, fn, length, holder, [], [])
}

/**
 *
 * @param {*} fn 回调函数
 * @param {*} length 回调函数参数的长度
 * @param {*} holder 占位符
 * @param {*} args 接收参数数组
 * @param {*} holders 占位符数组
 * @return {*}
 */
function _curry(fn, length, holder, args, holders) {
  return function (..._args) {
    let params = args.slice()
    // 代表这次的占位符数组
    let _holders = holders.slice()

    _args.forEach((arg, i) => {
      // 不存在占位符且占位符有记录
      if (arg !== holder && holders.length) {
        let index = holders.shift()
        _holders.splice(_holders.indexOf(index), 1)
        params[index] = arg
      }
      // 不存在占位符且占位符没有记录
      else if (arg !== holder && !holders.length) {
        params.push(arg)
      }
      // 存在占位符且占位符没有记录
      else if (arg === holder && !holders.length) {
        params.push(arg)
        _holders.push(params.length - 1)
      }
      // 存在占位符且占位符有记录
      else if (arg === holder && holders.length) {
        holders.shift()
      }
    })
    // params 中没有占位符才能执行函数
    if (params.length >= length && params.slice(0, length).every((i) => i !== holder)) {
      return fn.apply(this, params)
    } else {
      return _curry.call(this, fn, length, holder, params, _holders)
    }
  }
}
let fn = function (a, b, c, d, e) {
  console.log([a, b, c, d, e])
}

let _ = {} // 定义占位符
let _fn = curry(fn, 5, _) // 将函数柯里化，指定所需的参数个数，指定所需的占位符

_fn(1, 2, 3, 4, 5) // print: 1,2,3,4,5
_fn(_, 2, 3, 4, 5)(1) // print: 1,2,3,4,5
_fn(1, _, 3, 4, 5)(2) // print: 1,2,3,4,5
_fn(1, _, 3)(_, 4, _)(2)(5) // print: 1,2,3,4,5
_fn(1, _, _, 4)(_, 3)(2)(5) // print: 1,2,3,4,5
_fn(_, 2)(_, _, 4)(1)(3)(5) // print: 1,2,3,4,5

  26. sjush commented on Sep 22, 2022

    @sjush
    sjush
    on Sep 22, 2022

    function.length是形参的个数，如果参数数量未知呢

  27. xiaochengzi6 commented on Sep 22, 2022

    @xiaochengzi6
    xiaochengzi6
    on Sep 22, 2022 via email

  28. dengsong666 commented on May 11, 2023

    @dengsong666
    dengsong666
    on May 11, 2023
    obj.fn(1, 2, 3)

    这里 写成obj.fn(1, 2)(3)，this指向的还是obj么？

  29. oldmanzou commented on Jun 3, 2023

    @oldmanzou
    oldmanzou
    on Jun 3, 2023

    我是这么理解第二种写法的，就像理解递归函数一样。

    function sub_curry(fn) {
  const args = [].slice.call(arguments, 1)// fn之外的参数

  // 返回 记住之前传入参数的闭包
  return function () {
    return fn.apply(this, args.concat([].slice.call(arguments)))
  }
}

function curry(fn, length) {
  length = length || fn.length

  const slice = Array.prototype.slice

  // curry的作用，返回闭包
  return function () {
    // 不满足出口条件，返回闭包
    if (arguments.length < length) {
      const combined = [fn].concat(slice.call(arguments))

      // 调用sub_curry是希望得到一个能缓存argument的函数，还要改一下出口条件，只要传入length - arguments.length 个参数，就能满足出口条件
      return curry(sub_curry.apply(this, combined), length - arguments.length)
    } else {
      // 满足出口条件后，返回fn执行结果
      return fn.apply(this, arguments)
    }
  }
}

// 明确curry函数的作用：
// 1、返回闭包函数
// 2、确定进入出口的条件为：argument.length >= fn.length
// 3、执行闭包的最终出口是执行fn函数
// 4、在没到出口时，调用curry 返回闭包（参数传入辅助函数调用的结果和下一闭包的出口条件）

  30. HQHC commented on May 7, 2024

    @HQHC
    HQHC
    on May 7, 2024

    如果被curry的函数参数长度不固定呢，像这种
    function multiply(...numbers) {
    return numbers.reduce((a, b) => a * b, 1);
    }

  31. xxdz commented on Jul 8, 2024

    @xxdz
    xxdz
    on Jul 8, 2024
    function curry(fn, args) {
    var length = fn.length;

    args = args || [];

    return function() {

        var _args = args.slice(0),

            arg, i;

        for (i = 0; i < arguments.length; i++) {

            arg = arguments[i];

            _args.push(arg);

        }
        if (_args.length < length) {
            return curry.call(this, fn, _args);
        }
        else {
            return fn.apply(this, _args);
        }
    }
}


var fn = curry(function(a, b, c) {
    console.log([a, b, c]);
}); // 请问这里的fn是否也形成了一个闭包呢？

fn("a", "b", "c") // ["a", "b", "c"]
fn("a", "b")("c") // ["a", "b", "c"]
fn("a")("b")("c") // ["a", "b", "c"]
fn("a")("b", "c") // ["a", "b", "c"]

    我想问一下这段代码，问题写在注释中了

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    专题系列

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions