js--函數式編程

這兩天看書看到了函數式編程那節，感覺學到了挺多東西，之前看別人代碼都寫的挺漂亮，現在我寫的代碼是有點亂，所以還是要學習下別人的編程模式..

（1）平常寫的函數大多是接受值，合並值，返回值，比如經常寫的for循環:

function printArray(array){
    for(var i=0;i<array.length;i++){
         print(array[i]);  
    }      
}

但是如果我們想做print之外的事情呢？怎么辦？再寫一個相似的，未免顯得浪費，我們可以這樣

function forEach(array,action){
   for(var i=0;i<array.length;i++){
       action(array[i]);  
   }  
}
forEach(["a","b","c"],print);

通過利用匿名函數，在編寫for循環之類的可以省去很多無用的細節：

function sum(numbers){
    var total = 0;
    forEach(numbers,function(number){
         total+=number;
    })     
   return total;   
}

上面的例子中是“遍歷數組”，並使其抽象化，函數作為函數參數傳入....

（2）另一種是傳入函數參數，返回函數，可以在“高階函數”中傳入arguments

function negate(func){
    return function(x){
        return !func(x);  
    }
}
var isNotNaN = negate(isNaN);
isNotNaN(NaN);

如果想要反轉的函數接受參數大於1個，怎么辦？？  很簡單，借助apply方法，上下文傳入NULL

傳說中的組合模式：
function compose(f1,f2){
     return function(){
            return f1(f2.apply(null,arguments));
     };
}

var isNotNaN = compose(op["!"],isNaN);
isNotNaN(5); =>true

間接函數調用，如果運行次數較多還是不要用的好..

(3)sum函數實際上是算法的一個變體,該算法通常稱為規約

function reduce(combine,base,array){
   forEach(array,function(element){
       base = combine(base,element);
   });
}

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

reduce(add,0,array);

(4)另外一個與數組相關的有用的基本算法稱為“映射”。它能夠遍歷數組

function map(func,array){
   var result = [];
   forEach(array,function(element){
       result.push(func(element));
   });
   return result;
}

map(Math.round,[0.01,2,9,Math.PI]);

(5)下面這段代碼，可以研究下它的工作原理

function splitParagraph(text){
    function split(pos){
          if(pos == text.length) return [];
          else if(text.charAt(pos) == "*"){
                 var end = findClosing(“*”，pos+1);
                 frag = {type：“emphasized”,content:text.slice(pos+1,end)};
                 return [frag].concat(split(end+1));    //回調
          }  else if(text.charAt(pos) == "{"){
                 var end = findClosing(“{”，pos+1);
                 frag = {type：“emphasized”,content:text.slice(pos+1,end)};
                 return [frag].concat(split(end+1));    //回調
          }  else{
                var end = findOpeningOrEnd(pos),
                      frag = {type:"normal",content:text.splice(pos+1,end)};
                      return [frag].concat(split(end));

          }
    }
    function findClosing(character,from){
          var end = text.indexOf(character,from);
          if(end == -1) throw new Error("Missing closing ' "+character+"'");
          return end;
    }
    function findOpeningOrEnd(from){
          function indexOrEnd(character){
               var index = text.indexOf(character,from);
               return index = -1?text.length:index;
         }
         return Math.min(indexOrEnd("*"),indexOrEnd("{"));
    }
    
    return split(0);    
}        

這種函數的編程風格很獨特，使用遞歸而不是循環，其實遞歸效率是比較低的，改進如下：

function split(){
     var pos = 0,fragments = [];
     while(pop<text.lenght){
           if(text.charAt(pos) == "*"){
                 var end = findClosing("*",pos+1);
                 fragments.push({type:"emphasized",content:text.slice(pos+1,end)});
                  pos = end+1;
           }else if(text.charAt(pos) == "{"){
                  var end = findClosing("}",pos+1);
                  fragments.push({type:"footnote",content:text.slice(pos+1,end)});
           }
           else{
                 var end = findOpeningOrEnd(pos);
                 fragments.push({type：“footnote”,content:text.slice(pos,end)});
                 pos = end;
           }

     }
     return fragments;
}

（6）分布應用模式

function partial(func){
      var knownArgs = arguments;
      return function(){
           var realArgs = [];
           for(var i=1;i<knownArgs.length;i++){  //from 1
                realArgs.push(knowArgs[i]);
           }
           for(var i=0;i<arguments.length;i++){
                realArgs.push(arguments[i]);  
           }
           return func.apply(null,realArgs);
     }
}

map(partial(op["+"],1),[0,2,4,6,8,10]);  // op["+"] swithcase 的一個function