1.函数的柯里化：

• 概念：当一个函数有多个参数的时候先传递一部分参数调用它(这部分参数以后永远不变)，然后返回一个新的函数接收剩余的参数,返回结果

普通的纯函数:

function checkAge(min, age) {
   return age >= min;
 }
console.log(checkAge(18, 20)); //true

柯里化函数:

// function checkAge(min) {
//   return function (age) {
//     return age >= min;
//   };
// }
//箭头函数
let checkAge = (min) => (age) => age >= min
let checkAge18 = checkAge(18)
let checkAge20 = checkAge(20)
console.log(checkAge18(20)) //true
console.log(checkAge20(20)) //true

2.lodash中的curry：

function getSum(a, b, c) {
  return a + b + c
}
const curryed = _.curry(getSum)
console.log(curryed(1, 2, 3)) //6
console.log(curryed(1)(2, 3)) //6
console.log(curryed(1, 2)(3)) //6

//判断数组中是否有包含空白字符串的元素
let match = _.curry(function (reg, str) {
  return str.match(reg)
})
const haveSpace = match(/\s+/g)
const haveNumber = match(/\d+/g)
console.log(haveSpace('hello world')) //" "
console.log(haveNumber('hello world')) //null

3.手写实现curry方法:

//求和函数
function getSum(a, b, c) {
  return a + b + c
}
function curry(func) {
  //返回一个函数
  return function currieds(...args) {
    //判断实参与形参个数
    if (args.length < func.length) {
      //实参个数小于形参个数,返回currieds函数,并传入参数
      return function () {
        //合并实参与形参
        return currieds(...args.concat(Array.from(arguments)))
      }
    }
    //实参大于等于形参,直接返回所传入的函数
    return func(...args)
  }
}

const currieds = curry(getSum)
console.log(currieds(1, 2, 3)) //6
console.log(currieds(1)(2, 3)) //6
console.log(currieds(1, 2)(3)) //6

不限参数

// 不限数量参数
function sum(...rest) {
  // 第一次执行时，定义一个数组专门用来存储所有的参数
  var _args = Array.prototype.slice.call(arguments)
  // 在内部声明一个函数，利用闭包的特性保存_args并收集所有的参数值
  var _adder = function () {
    _args.push(...arguments)
    return _adder
  }
  // 利用toString隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
  _adder.toString = () => _args.reduce((a, b) => a + b)
  return _adder
}
console.log(Number(sum(1)(2)(3))) // 6
console.log(Number(sum(1, 2, 3)(4))) // 10
console.log(Number(sum(1)(2)(3)(4)(5))) // 15

总结:

· 柯里化可以让我们给一个函数传递较少的参数得到一个已经记住了某些某些固定参数的新函数
· 这是一种对函数参数的 '缓存'
· 让函数变得更灵活，让函数的粒度更小
· 可以把多远函数转换成一元函数，可以组合使用函数产生强大的功能