引言

我們不妨以兩數(shù)相加為例子，遞進說明。

我們通常是這樣寫一個函數(shù)來求得 兩數(shù)相加 的值：

function sum(a,b){
    console.log(a+b)
}
sum(1,2)

這樣寫一點毛病沒有！

不過呢？問題總會在發(fā)展中產(chǎn)生，產(chǎn)品經(jīng)理又要加一個值，需求：三數(shù)相加；

咱通常來說，第一時間，就在原基礎上，直接再加一個參數(shù)就是了；

于是，修改后像是這樣：

function sum(a,b,c){
    console.log(a+b+c)
}
sum(1,2,3)

問：這樣寫，有毛病嗎？？

答：太有毛病了！

這樣一改，既違反了：“開閉原則”、又違反了：“單一職責原則”。

為不太熟悉設計原則的小伙伴們，簡單解釋下：

• 什么是“開閉原則”？即：我們編程中要盡可能的避免直接修改函數(shù)、類或模塊，而是要在原有基礎上拓展它；
• 什么是“單一職責原則”？即：每個函數(shù)、類或模塊，應該只負責一個單一的功能；

首先，咱修改了 sum 函數(shù)的傳參以及內(nèi)部的調(diào)用 ⇒ 則違反“開閉原則”

其次，sum 函數(shù)本來只負責兩數(shù)相加，修改后，它又負責三數(shù)相加，職責已經(jīng)發(fā)生了變化 ⇒ 則違反 “單一職責原則”；

如果正規(guī)按照單一責任來寫，應該是：

// 負責兩數(shù)相加
function sum2(a,b){
    console.log(a+b)
}
// 負責三數(shù)相加
function sum3(a,b,c){
    console.log(a+b+c)
}

事實上，是不可能這樣去寫的，因為如果有一萬個數(shù)相加，得寫一萬個函數(shù)。

而 加法只有一個?。?不管你最終要加幾個值，總是要一個加一個。

于是乎，我們設想，能不能寫一個這樣的函數(shù)：它的功能，就是“加”，參數(shù)跟幾個，我就加幾個。

// 負責“加法”，
function addCurry(){
    ...
    ...
    ...
}
addCurry(1)(2) // 兩數(shù)相加
addCurry(1)(2)(3) // 三數(shù)相加
...
addCurry(1)(2)(3)...(n) // n 數(shù)相加

沒錯，這個函數(shù)就是：柯里化?。。ɑ蛘哒f這個過程叫柯里化，這個思想叫柯里化，本瓜認為這里不需要太死扣定義）

接著，我們一步步來試試，它會是怎樣構成的？

為了能夠?qū)崿F(xiàn)一個加一個，即存儲參數(shù)的目的，我們想一想，還有什么法寶？

沒錯，JS 奧義：閉包！

其實，本瓜時常想，閉包的終極秘密是什么？最后將其理解為 4 個金光閃閃的大字：延遲處理！

什么意思？簡單解釋下：

function directHandle(a,b){
    console.log("直接處理",a,b)
}
directHandle(111,222)
// 直接處理 111 222
function delayHandle(a){
    return function(b){
         console.log("延遲處理",a,b)
    }
}
delayHandle(111)
// ? (b){
//	    console.log("延遲處理",a,b)
//	}

如上 delayHandle(111) 不像 directHandle(111,222) 直接打印值，而是先返回一個函數(shù) f(b)；111 也被臨時保存了，delayHandle(111)(222)，則得到相同的輸出。這就是：延遲處理的思想。

另外補一句：

延遲處理是函數(shù)式編程的精華所在，在不能保證每個函數(shù)都是純函數(shù)的前提下，在管道處理的最后，再進行處理，能最大程度的保證減少副作用。也就是 Monad 思想，此處不做展開。

言歸正傳，于是乎，我們借用閉包來實現(xiàn)最初版的柯里化：

// 兩數(shù)相加
function addCurry(a){
    return function(b){
            console.log(a+b)
    }
}
addCurry(1)(2)
// 三數(shù)相加
function addCurry(a){
    return function(b){
        return function(c){
             console.log(a+b+c)
        }
    }
}
addCurry(1)(2)(3)

寫兩個閉包的過程，聰明的你一定就明白了，這樣一直寫下去，不就是遞歸嗎？！

于是乎，我們知道，當參數(shù)是 n 個的時候，需要遞歸 n-1 次 return function

于是乎，addCurry 寫法如下：

 let arr = []
 function addCurry() {
     let arg = Array.prototype.slice.call(arguments); // 遞歸獲取后續(xù)參數(shù)
     arr = arr.concat(arg);
      if (arg.length === 0) { // 如果參數(shù)為空，則判斷遞歸結束
          return arr.reduce((a,b)=>{return a+b}) // 求和
      } else {
          return addCurry;
      }
  }
addCurry(1)(2)(3)()

OK，至此，，大功告成??！

以上，用最簡單的代碼解釋了 —— 為什么我說：柯里化 == 閉包+遞歸 ？

柯里化是一種思想，上面的 addCurry 可以說是最簡單的一種實踐。在函數(shù)式編程中，Curry 更是大放異彩，比如 compose(fn1)(fn2)(fn3)…(fnN)(args) 等等。

如果以后有人再問你柯里化，可以往這個方向上答。。。

以上就是閉包結合遞歸等于柯里化原理解析的詳細內(nèi)容，更多關于閉包結合遞歸等于柯里化的資料請關注腳本之家其它相關文章！

最新評論