定义：当一个函数有多个形参需要接受时，先传递一部分参数，此时返回一个函数，等待接受剩余的参数，并会缓存之前的传递的参数;

如图：

  1. /**
  2.  * @desc 柯里化
  3.  */
  5. function checkAge(mini){
  6.     return function(age){
  7.         return age >= mini;
  8.     }
  9. }
  10. const p1 = checkAge(18)(20)
  11. console.log(p1)
  13. //简写
  14. const p1 = mini => age => age >= mini;
  15. console.log(p1(18)(20));

可以借助lodash库提供的Curry，来实现柯里化函数

  1. /**
  2.  * 柯里化案例
  3.  */
  5. const _ = require("lodash");
  6. // 调用柯里化函数
  7. const serchTest = _.curry((reg, str) => {
  8.   //   return reg.test(str);
  9.   return str.match(reg);
  10. });
  12. const haveSpace = serchTest(/\s+/g);
  14. // const saveLokersChinese = serchTest(/^(?:[\u4e00-\u9fa5·]{2,16})$/)
  15. // console.log(saveLokersChinese('@#!@3'))
  17. // const saveLokersEmail = serchTest(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/);
  18. // console.log(saveLokersEmail('a183123123123@163.com'))
  20. // 过滤数组中空白的元素
  21. const filter = _.curry((func, array) => {
  22.   return array.filter(func);
  23. });
  25. const result = filter((item) => {
  26.   return item.match(/\s+/g);
  27. });
  28. console.log(result(["hello word", "jack rows", "123 44523", ""]));

柯里化实现原理是怎样的？
关键点：需要注意实参与形参之间长度的比较，当实参大于形参，即执行回调函数返回结果；当实参小于形参，立即返回一个已经缓存参数的函数，并等待接收剩余的参数

  1. // lodash的curry
  2. const _ = require("lodash");
  3. function getSum(a, b, c, d) {
  4.   return a + b + c + d;
  5. }
  6. const sum = _.curry(getSum);
  7. console.log(sum(1, 2, 3, 4));
  8. console.log(sum(1)(2)(3, 4));
  9. console.log(sum(1, 2)(3, 4));
  10. console.log(sum(1, 2, 3)(4));
  13. // 自定义的curry函数
  14. /**
  15.  *
  16.  * @param {function} func 要执行的函数
  17.  * @return {any} func-value 返回func执行的结果
  18.  */
  19. function curry(func) {
  20.   return function curryFn(...args) {
  21.     // 当实参<形参时，返回一个函数，并等待接受剩余参数
  22.     if (args.length < func.length) {
  23.       return function () {
  24.         // 合并每次调用函数传递的参数
  25.         return curryFn(...[...args, ...Array.from(arguments)]);
  26.       };
  27.     }
  28.     // 当实参>=形参时，调用传递的构造函数；
  29.     return func(...args);
  30.   };
  31. }

总结：

  • 柯里化可以让我们通过传递较少的参数得到一个已经记住固定参数的新函数
  • 这个新函数能够对参数进行缓存
  • 让函数变得更灵活，让函数进行细腻化
  • 能够将多元函数转换成一元函数，并且可以组合成功能更加强大的组合函数