柯里化时一种将使用多个参数的一个函数转化成一系列使用一个参数的函数的技术
优点就是降低代码的复用性，提高适应性
实现柯里化

  1.         // 实现柯里化
  2.         function add(a,b,c,d){
  3.             return a+b+c+d;
  4.         }
  5.         // 当参数满足时，才会有值,不然其余参数为unfinished 
  6.         function FixedParmasCurry (fn){
  7.             var _arg = [].slice.call(arguments,1);
  8.             return function(){
  9.                 var newArg = _arg.concat([].slice.call(arguments,0));
  10.                 return fn.apply(this,newArg);
  11.             }
  12.         }
  13.         function Curry(fn,length){
  14.             var length = length || fn.length;
  15.             return function(){
  16.                 if(arguments.length < length){
  17.                     var combinded =[fn].concat([].slice.call(arguments,0));
  18.                     return Curry(FixedParmasCurry.apply(this,combinded),length - arguments.length);
  19.                 }else{
  20.                     return fn.apply(this,arguments);  
  21.                 }
  22.             }
  23.         }
  24.         var ad = Curry(add);
  25.         var a = ad(1)(2)(3)(4); // 当参数为指定长度才会执行

image.png

  1.        //承接上面柯里化的实现 
  2.                 function ajkx(method,url,data){
  3.             console.log(method,url,data);
  4.         }
  5.         var ajkxCurry = Curry(ajkx); 
  6.         var PostAjax = ajksCurry("post");
  7.         PostAjax=('www.baidu1.com','name=cst&code=1');
  8.         // 再次简化
  9.         // PostAjax=('www.baidu.com','name=cst&code=1');
  10.         var PostTextAjax = PostAjax('www.baidu.com');
  11.         PostTextAjax("name=cst&code=12")

袁老师柯里化的实现，代码较少
在函数式编程中，科里化最重要的作用是把多参函数变为单参函数

  1. /**
  2.  * 科里化函数
  3.  * 在函数式编程中，科里化最重要的作用是把多参函数变为单参函数
  4.  */
  5. this.myPlugin.curry = function (func) {
  6.     //得到从下标1开始的参数
  7.     var args = Array.prototype.slice.call(arguments, 1);
  8.     var that = this;
  9.     return function () {
  10.         var curArgs = Array.from(arguments); //当前调用的参数
  11.         var totalArgs = args.concat(curArgs);
  12.         if (totalArgs.length >= func.length) {
  13.             //参数数量够了
  14.             return func.apply(null, totalArgs);
  15.         }
  16.         else {
  17.             //参数数量仍然不够
  18.             totalArgs.unshift(func);
  19.             return that.curry.apply(that, totalArgs);
  20.         }
  21.     }
  22. }

科里化.htmlhelpers.js

函数管道

函数管道：将多个单参函数组合起来，形成一个新的函数，这些函数中，前一个函数的输出，是后一个函数的输入

  1.         // 函数管道：将多个单参函数组合起来，形成一个新的函数，这些函数中，前一个函数的输出，是后一个函数的输入
  2.         this.myPlugin.pipe = function(){
  3.             var args = Array.from(arguments);
  4.             return function(val){
  5.                 // 函数管道精简版
  6.                 return args.reduce(function(prev,icur){
  7.                     return icur(prev)
  8.                 },val)
  10.                 // 函数管道
  11.                 for(var i = 0 ; i < args.length ; i++){
  12.                 var fun = args[i]
  13.                 val = fun(val);
  14.                 }
  15.                 return val;
  16.             }
  17.         }

例子：

  1.        this.myPlugin = {}
  2.         // 将字符串修改为小驼峰格式
  3.         //将字符串中每一个单词首字母大写
  4.         function everyFirstLetterUp(str){
  5.             return str.replace(/\b(\w)(\w*)\b/g,function($,$1,$2){
  6.                 return $1.toUpperCase() + $2
  7.             })
  8.         }
  9.         //将字符串中除首字母外的其他字母小写
  10.         function otherLetterLower(str){
  11.             return str.replace(/\b(\w)(\w*)\b/g,function($,$1,$2){
  12.                 return $1 + $2.toLowerCase()
  13.             })
  14.         }
  15.         //去掉字符串中所有的空白字符
  16.         function removeEmpty(str){
  17.             return str.replace(/\s+/g,"")
  18.         }
  19.         //将字符串中第一个单词字符小写
  20.         function firstLetterLower(str){
  21.             return str.replace(/\w/,function($){
  22.                 return $.toLowerCase()
  23.             })
  24.         }
  25.         // 函数管道：将多个单参函数组合起来，形成一个新的函数，这些函数中，前一个函数的输出，是后一个函数的输入
  26.         this.myPlugin.pipe = function(){
  27.             var args = Array.from(arguments);
  28.             return function(val){
  29.                 // 函数管道精简版
  30.                 return args.reduce(function(prev,icur){
  31.                     return icur(prev)
  32.                 },val)
  34.                 // 函数管道
  35.                 for(var i = 0 ; i < args.length ; i++){
  36.                 var fun = args[i]
  37.                 val = fun(val);
  38.                 }
  39.                 return val;
  40.             }
  41.         }
  42.         var smallCamel = myPlugin.pipe(everyFirstLetterUp, firstLetterLower,
  43.             otherLetterLower, removeEmpty);
  44.         console.log(smallCamel("    MY     fIrST    naME"));

helpers.js函数管道.html