柯里化

一个接受多个参数的函数转换为一系列接受单个参数的函数的技术。

// 未柯里化的函数
function add(a, b) {
  return a + b;
}

//封装现有函数
function f1(func){
    function f2(...args){
        if(args.length >= func.length){
            return func.apply(this,args)
        }
        return function(...args2) {
            return f2.apply(this,args.concat(args2));
        }
    }
    return f2;
}


// 柯里化后的函数
function curriedAdd(a) {
  return function(b) {
    return a + b;
  }
}

// 使用未柯里化的函数
console.log(add(2, 3)); // 输出: 5

// 使用柯里化后的函数
const add2 = curriedAdd(2);
console.log(add2(3)); // 输出: 5
//无限调用
const ff = (a) => {
    let num = a||0
    const item = b => {
        num += b;
        item.num = num;
        return item;
    }
    return item;
}
console.log(ff(1)(2)(3).num)

写一道函数柯里化(sum(1)(2)(3)(4)(5)(6) sum(1, 2)(3, 4)(5)

function curry(fn) {
    return function curried(...args) {
            return function(...moreArgs) {
                if(!moreArgs[0]){
                    return fn.apply(this,args);
                }
                return curried.apply(this, args.concat(moreArgs));
            };
    };
}
function sum(...args) {
    return args.reduce((pre,cur) => pre + cur,0);
}

const curriedSum = curry(sum);
console.log(curriedSum(1)(2)(3)(4)(5)(6)())
console.log(curriedSum(1, 2)(3, 4)(5))

实现一个函数 fun，例： fun(1).add(1).min(2).num // 最终输出为 -2

function fun(initialValue) {
    let accumulator = initialValue;

    return {
        add: function(value) {
            accumulator += value;
            return this; // 返回当前对象，以便可以链式调用
        },
        min: function(value) {
            accumulator -= value;
            return this; // 返回当前对象，以便可以链式调用
        },
        num: function() {
            return accumulator; // 返回当前累加器的值
        }
    };
}

// 使用示例
const result = fun(1).add(1).min(2).num();
console.log(result); // 输出: -2