// 通過ES6箭頭函數(shù)構(gòu)造將更加簡單
const addCurry = (a) => (b) => (c) => a + b + c;

// 調(diào)用也可以這樣
addCurry(10)(5)(3); // 結(jié)果: 18

柯里化的應(yīng)用

? ? ? ?柯里化（Currying）分解了函數(shù)設(shè)計過程，將運行的步驟拆分為每一個單一參數(shù)的 lambda 演算。這里例舉一個在 JavaScript 中用于做強制類型判斷的示例：

// 創(chuàng)建一個用于檢測數(shù)據(jù)類型的函數(shù) checkType() 
const checkType = (e, typeStr) => Object.prototype.toString.call(e) === '[object '+typeStr+']';

// 調(diào)用示范
checkType(12, 'Number');            // 結(jié)果：true
checkType(16.8, 'Number');          // 結(jié)果：true
checkType(NaN, 'Number');           // 結(jié)果：true
checkType(Infinity, 'Number');      // 結(jié)果：true
checkType('abc', 'String');         // 結(jié)果：true
checkType(true, 'Boolean');         // 結(jié)果：true
checkType({}, 'Object');            // 結(jié)果：true
checkType([], 'Array');             // 結(jié)果：true
checkType(null, 'Null');            // 結(jié)果：true
checkType(undefined, 'Undefined');  // 結(jié)果：true
checkType(checkType, 'Function');   // 結(jié)果：true
checkType(Symbol(), 'Symbol');      // 結(jié)果：true

使用這一的方式構(gòu)建的函數(shù) checkType() 具備了高通用性，但適用性則略差。我們發(fā)現(xiàn)每次的調(diào)用過程，使用者都需要編寫參數(shù) typeStr 表示的類型字符串，增加了函數(shù)的應(yīng)用復(fù)雜度。此時作為設(shè)計者，就可以對該函數(shù)加以改造，使其生成多個具備高適用性的獨立函數(shù)：

// 檢測值是否是 Number
const isNumber = (e) => checkType(e, 'Number');
// 檢測值是否是 String
const isString = (e) => checkType(e, 'String');
// 檢測值是否是 Boolean
const isBoolean = (e) => checkType(e, 'Boolean');
// 檢測值是否是 Object
const isObject = (e) => checkType(e, 'Object');
// 檢測值是否是 Array
const isArray = (e) => checkType(e, 'Array');
// 檢測值是否是 Null
const isNull = (e) => checkType(e, 'Null');
// 檢測值是否是 Undefined
const isUndefined = (e) => checkType(e, 'Undefined');
// 檢測值是否是 Function
const isFunction = (e) => checkType(e, 'Function');
// 檢測值是否是 Symbol
const isSymbol = (e) => checkType(e, 'Symbol');

柯里化無限調(diào)用

? ? ? ?柯里化（Currying）分解了函數(shù)設(shè)計過程，將運行的步驟拆分為每一個單一參數(shù)的 lambda 演算。我們可以通過遞歸的方式，來構(gòu)造出一個可進行無限調(diào)用，并返回相同的累加函數(shù)的 柯里化函數(shù)：

// 一個永遠累加的函數(shù)，返回結(jié)果的新函數(shù)中緩存上一次調(diào)用，并進行數(shù)據(jù)累加
// 最終的數(shù)據(jù)依賴 success 回調(diào)函數(shù)獲取
const alwaysAdd = function f1(nexter1){
    const n1 = nexter1;
    typeof n1.success == 'function' && n1.success(n1.value);
    return function f2(nexter2){
        const n2 = nexter2;
        return f1( {value: n1.value+n2.value, success: n2.success} );
    }
}

調(diào)用方式如：

const r1 = alwaysAdd({value: 2});
const r2 = r1({value: 5});
const r3 = r2({value:4, success: (result)=>console.log('結(jié)果: ', result)});

以這樣的方式，我們構(gòu)建的參數(shù)是一個簡單對象 nexter，該對象至少包含一個 value 屬性，用于描述本次累加的值。如果希望獲取累加結(jié)果，則為 nexter 對象賦予函數(shù)屬性 success 即可。結(jié)果會以實參的形式，傳遞給 success 函數(shù)用于傳遞通知。

一個簡單的 Promise

? ? ? ?Promise 對象無論是構(gòu)造函數(shù)還是后續(xù)的鏈?zhǔn)秸{(diào)用中，都能看到柯里化設(shè)計的影子：接收單一參數(shù)，返回一個 Promise ：

// 構(gòu)建一個超級簡單的 Promise 結(jié)構(gòu)
class MyPromise{
    constructor(executor) {
        this.value = null;
        typeof executor == 'function' && executor(this.resolve.bind(this), this.reject.bind(this));
    }
                
    then(success){
        const result = success(this.value);
        const mp = new MyPromise();
        mp.value = result;
        return mp;
    }
                
    resolve(value){
        this.value = value;
    }
                
    reject(err){
        this.err = err;
    }
}

調(diào)用方式為：

// 構(gòu)建一個 MyPromise 對象
const mp1 = new MyPromise((resolve, reject) => {
    resolve(10);
});

// 鏈?zhǔn)秸{(diào)用求值
mp1.then( r => {
    console.log('mp1 r => ', r);    // 結(jié)果: 10
    return r + 3;
} ).then( r => {
    console.log('mp2 r => ', r);    // 結(jié)果: 13
    return r + 5;
} ).then( r => {
    console.log('mp3 r => ', r);    // 結(jié)果: 18
} );