Function Currying

Simple, Beautiful, Interesting

function curry(fn, ...args){
    return args.length === fn.length ? 
        fn(...args) : 
        (...next_args) => curry(fn, ...args, ...next_args); 
}

Next

function mul(a, b, c){
    return a * b * c; 
}
// mul(3, 4, 4); => 48 

let a = curry(mul); 

a(3)(4)(4); 
// => 48 

a(3, 4, 4); 
// => 48 

a(3)(4, 4); 
// => 48 

a()()()()()(3, 4)(4); 
// => 48 

S

// 來晚了 ...

最簡單最完美實(shí)現(xiàn)

// es6
   const mul = (x) => {
    let sum = x
    let curried = (y) => {
        sum = sum * y
        return curried
    }
    curried.toString = () => sum
    return curried
   }
    console.log(mul(1)) //1
    console.log(mul(1)(2))//2
    console.log(mul(1)(2)(3))//6
    console.log(mul(1)(2)(3)(4))//24
    ...
    
   // es5
 function mul(x){
  var sum = x
  var curried = function(y){
    sum = sum * y
    return curried
  }
  curried.toString=function(){
    return sum 
  }
  return curried
}
    console.log(mul(1)) //1
    console.log(mul(1)(2))//2
    console.log(mul(1)(2)(3))//6
    console.log(mul(1)(2)(3)(4))//24
    ...

函數(shù)柯里化 了解一下？

        // 固定參數(shù)實(shí)現(xiàn)
        const result = x => y => z => x * y * z;
        result(3)(4)(4) // 48;
        // 柯里化實(shí)現(xiàn)
        function curry(fn) {
            const len = fn.length;
            return function curried() {
                const args = Array.prototype.slice.call(arguments);
                if (args.length >= len) {
                    return fn.apply(this, args);
                }            
                return function () {
                    return curried.apply(this, args.concat(Array.prototype.slice.call(arguments)));
                };
            };
        }
        const result = curry(function (a, b, c) {
            return a * b * c;
        });
        result(3)(4)(4); // 48

固定3個(gè)參數(shù)的的柯里化。。。

const curry3 = fn=> a => b => c => fn(a,b,c);
const mutl3 = (a, b, c) => a * b * c;
const curried3 = curry3(mutl3);
let result = curried3(3)(4)(4);
console.log(result);

如果是更加通用的累乘，參數(shù)不定，就不能這么用了。

const curry = fn => {
    let _args = [];
    const _fn = (...args) => {
        _args.push(...args);
        return args.length >= 1 ? _fn : fn(..._args);
    }
    return _fn;
}
// 累乘
const multiplication = curry(function() {
    return Array.prototype.reduce.call(arguments, (acc, val) => {
        return acc * val;
    }, 1);
});
let result = multiplication(3)(4)(4)();
console.log(result);

想深入了解問題本質(zhì)，建議了解下 柯里化

沒法實(shí)現(xiàn) 。 如果 a(3)(4)===12 那么 typeof（a(3)(4))必定是number 那么number必定不能像函數(shù)一樣調(diào)用

這里有一個(gè)之前寫好的通用的currying函數(shù)，傳入乘法運(yùn)算function即可：https://github.com/Jiasm/note...

鏈?zhǔn)綀?zhí)行返回值必定為函數(shù)

const a = () => () => () => 48

const a = x => Object.assign(
  y => a(x * y),
  {
    valueOf: () => x,
    toString: () => String(x),
  }
)

a(3)(4)(4) == 48         // ==> true
String(a(3)(4)(4))       // ==> "48"
console.log(a(3)(4)(4))  // ==> f 48