简介

柯里化，英语：Currying，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。 ——维基百科

>

示例 

  1. // 普通的add函数
  2. function add(x, y) {
  3.     return x + y
  4. }
  6. // currying后
  7. function curryingAdd(x) {
  8.   return function (y) {
  9.       return x + y
  10.   }
  11. }
  13. curryingAdd(1)(2)   // 3

作用

1. 参数复用

  1. function curryingCheck(reg) {
  2.   return function(txt) {
  3.       return reg.test(txt)
  4.   }
  5. }
  7. var hasDigit = curryingCheck(/\d+/g)
  8. var hasLetter = curryingCheck(/[a-z]+/g)
  10. hasDigit('test1')     // true
  11. hasDigit('test')           // false
  12. hasLetter('123')      // false

2. 提前确认

  3. const on = (document, element, event, handler) => {
  4.   if (document.addEventListener) {
  5.       element.addEventListener(event, handler, false);
  6.   }
  7.   else {
  8.       element.attachEvent('on' + event, handler);
  9.   }
  10. };
  12. // 提前确认注册事件的方法，就不用在每次调用on时候确认
  13. const on = (doc => {
  14.   return doc.addEventListener
  15.     ? (element, event, handler) => {
  16.           element.addEventListener(event, handler, false);
  17.       }
  18.     : (element, event, handler) => {
  19.           element.attachEvent('on' + event, handler);
  20.       }
  21. })(document);

3. 延迟运行

  1. function add(...args) {
  2.     return args.reduce((prev, current) => prev + current);
  3. }
  5. add(1, 2, 3, 4);
  7. function curry(fn){
  8.   let args = [];
  9.   return function cb() {
  10.     if(arguments.length < 1) {
  11.         return fn(...args);
  12.     }
  13.     else {
  14.       args = [...args,...arguments]
  15.       return cb;
  16.     }
  17.   }
  18. }
  20. cAdd = curry(add);
  22. cAdd(1)(2)(3)(4)();

延迟执行实际上就是当我们调用这个方法时，不会立即执行，或者说在参数符合规定的时候才会执行我们真正想执行的内容。

实现

1. 通用实现

  1. function currying(fn, ...rest) {
  2.   return function(...args) {
  3.       return fn(...rest, ...args);
  4.   }
  5. }
  7. function sum(a, b, c, d) {
  8.   console.log(a + b + c + d)
  9. }
  10. const add = currying(sum, 1, 2);
  11. add(3, 4);
  13. // 执行结果
  14. 10

2. 递归实现

  1. function add(a, b, c, d) {
  2.     console.log(a + b + c + d);
  3. }
  5. const curriedAdd = currying(add);
  7. curriedAdd(1)(2)(3)(4); // 10
  8. curriedAdd(1, 2, 3)(4); // 10
  9. curriedAdd(1, 2, 3, 4); // 10
  11. function currying(fn) {
  12.     const len = fn.length;
  13.     let _args = [];
  14.     const curry = () => {
  15.         return function (...args) {
  16.             // 如果参数攒够了就执行
  17.             if (_args.length + args.length >= len) {
  18.                 const result = fn(..._args, ...args);
  19.                 // 执行完重置_args
  20.                 _args = [];
  21.                 return result;
  22.             }
  23.             // 参数不够就继续攒
  24.             else {
  25.                 _args = [..._args, ...args];
  26.                 return curry();
  27.             }
  28.         }
  29.     }
  30.     return curry();
  31. }

经典面试题

  1. // 实现一个add方法，使计算结果能够满足如下预期：
  2. // add(1)(2)(3) == 6 // true
  3. // add(1, 2, 3)(4) == 10 // true
  4. // add(1)(2)(3)(4)(5) == 15 // true
  6. function add() {
  7.   // 第一次执行时，定义一个数组专门用来存储所有的参数
  8.   var _args = Array.prototype.slice.call(arguments);
  10.   // 在内部声明一个函数，利用闭包的特性保存_args并收集所有的参数值
  11.   var _adder = function() {
  12.     _args.push(...arguments);
  14.     return _adder;
  15.   };
  17.   // 利用toString隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
  18.   _adder.toString = function () {
  19.     return _args.reduce(function (a, b) {
  20.         return a + b;
  21.     });
  22.   }
  23.   return _adder;
  24. }