Javascript 可变电流和函数

我需要一个js sum函数来像这样工作：

sum(1)(2) = 3
sum(1)(2)(3) = 6
sum(1)(2)(3)(4) = 10 
etc.

我听说这是办不到的。但是听说如果把

+

加在

前面，求和

就可以了。

---

比如

+和（1）（2）（3）（4）

有什么办法吗？

不知道我是否明白你想要什么，但是

函数和（n）{
var v=函数（x）{
返回和（n+x）；
};
v、 valueOf=v.toString=function（）{
返回n；
};
返回v；
}
控制台日志（+sum（1）（2）（3）（4））您可以使用以下功能

function add(num){
   add.sum || (add.sum = 0) // make sure add.sum exists if not assign it to 0
   add.sum += num; // increment it
   return add.toString = add.valueOf = function(){ 
      var rtn = add.sum; // we save the value
      return add.sum = 0, rtn // return it before we reset add.sum to 0
   }, add; // return the function
}

由于函数是对象，我们可以向它添加属性，当它被访问时我们会重置属性。
要使
sum（1）
可调用为
sum（1）（2）
，它必须返回一个函数

可以调用该函数，也可以将其转换为值为的数字

function sum(a) {

   var sum = a;
   function f(b) {
       sum += b;
       return f;
    }
   f.toString = function() { return sum }
   return f
}

这是一个使用上次通话中的空括号作为结束键的示例（来自我上次的采访）：

第（1）（4）（66）（35）（0）款


函数和（numberOne）{
var计数=数字；
返回函数by（numberTwo）{
if（numberTwo==未定义）{
返回计数；
}否则{
计数+=数字2；
返回；
}
}
}
控制台日志（总和（1）（4）（66）（35）（0）（）我将此修订作为自己的帖子发布，因为我显然还没有足够的声誉将其作为评论。这是对@Rafael优秀解决方案的修订


函数和（n）{
var v=x=>和（n+x）；
v、 valueOf=（）=>n；
返回v；
}
控制台日志（+sum（1）（2）（3）（4））//10
这里有一个使用ES6和
toString
的解决方案，类似于@Vemba


函数添加（a）{
让咖喱=（b）=>{
a+=b
回流咖喱
}
curry.toString=（）=>a
回流咖喱
}
控制台日志（添加（1））
控制台日志（添加（1）（2））
控制台日志（添加（1）（2）（3））
console.log（添加（1）（2）（3）（4））
函数和（a）{
设res=0；
函数getarrSum（arr）{
返回arr.reduce（（e，sum=0）=>{sum+=e；返回sum；}）
}
函数calculateSumPerArgument（参数）{
设res=0；
如果（arguments.length>0）{
for（设i=0；i
另一个略短的方法：


const sum=a=>b=>b？总和（a+b）：a；
console.log(
第（1）（2）款，
第（3）（4）（5）款（）
);这里是使用迭代过程的另一种功能方法

const sum = (num, acc = 0) => {
    if (!num) return acc;
    return x => sum(x, acc + num)
}

sum(1)(2)(3)()

还有一行

const sum = (num, acc = 0) => !num ? acc : x => sum(x, acc + num)

sum(1)(2)(3)()

以下是一个在ES6 Javascript中使用通用变量curry函数的解决方案，并警告说调用参数需要最终的
（）
：

const curry = (f) =>
   (...args) => args.length? curry(f.bind(0, ...args)): f();

这里还有一个不需要
（）
，使用中的
valueOf
。我觉得以这种方式使用
valueOf
对阅读您的代码的人来说（或者根本不使用）是非常混乱的，但每个人都有自己的想法

答案中的
toString
是不必要的。在内部，当javascript执行类型协同时，它总是在调用
toString（）
之前调用
valueOf（）

可能是一个老问题，但只是一个小小的扩展答案


函数和（）{
var args=[]；
args.push（…参数）；
函数sumOfAllArguments（）{
返回参数减少（（上一个，项目）=>上一个+项目，0）
}
函数v（）{
参数&&args.push（…参数）；
return arguments.length==0？sumOfAllArguments（）：v；
}
v、 valueOf=v.toString=所有参数之和；
返回v；
}
console.log（sum（2）（2）（2）（）//6
console.log（sum（2）（2）（2）.toString（））//6
console.log（sum（2）（2）（2）.valueOf（））/6
console.log（+sum（2）（2）（2））//6
console.log（sum（2）（2）（2））//f6
log（sum（2,2,2）（2,2）（2））/f 12
log（sum（2）（2,2）（2）（）//8
这里有一个更通用的解决方案，也适用于非一元参数：


const sum=函数（…args）{
让总数=args.reduce（（acc，arg）=>acc+arg，0）
函数添加（…args2）{
如果（args2.长度）{
总计=args2。减少（（acc，arg）=>acc+arg，总计）
返回添加
}
返回总数
}
返回添加
}
document.write（sum（1）（2）（，“
”）与一元参数
write（sum（1,2）（，“
”）//带有二进制参数
document.write（sum（1）（2）（3）（，“
”）与一元参数
write（sum（1）（2,3）（，“
”）与二进制参数
document.write（sum（1）（2）（3）（4）（，“
”）与一元参数
使用三元参数编写（sum（1）（2,3,4）（，“
”）//新的ES6方式，简洁

要终止调用并获取最终值，必须在末尾传递empty（）

const sum= x => y => (y !== undefined) ? sum(x + y) : x;

这样称呼它-

sum(10)(30)(45)();

试试这个

function sum (...args) {
  return Object.assign(
    sum.bind(null, ...args),
    { valueOf: () => args.reduce((a, c) => a + c, 0) }
  )
}

console.log(+sum(1)(2)(3,2,1)(16))

在这里你可以看到一篇关于带无限参数的函数的中篇文章

在查看了这里的其他一些解决方案后，我想提供我的两个解决方案

使用ES6处理两个项目：

const sum=x=>y=>（y！==未定义）+x++y:+x
和（2）（2）//4

这里我们指定两个参数，如果第二个参数不存在，我们只返回第一个参数

对于三个或更多的项目，它变得有点棘手；这是我的解决办法。对于任何其他参数，可以将其作为第三个参数添加

const sum=x=>（y=0）=>（…z）=>+x++y++z.reduce（（上一个，当前）=>上一个+当前，0）
和（2）（（）//2
和（2）（2）（//4
和（2）（2）（2）//6
和（2）（2）（2,2）//8

我希望

// invokes a function if it is used as a value
const autoInvoke = (f) => Object.assign(f, { valueOf: f } );

const curry = autoInvoke((f) =>
   (...args) => args.length? autoInvoke(curry(f.bind(0, ...args))): f());


const sum = (...values) => values.reduce((total, current) => total + current, 0)
curry(sum)(2)(2)(1) + 0 == 5 // true

const sum= x => y => (y !== undefined) ? sum(x + y) : x;

sum(10)(30)(45)();

function sum (...args) {
  return Object.assign(
    sum.bind(null, ...args),
    { valueOf: () => args.reduce((a, c) => a + c, 0) }
  )
}

console.log(+sum(1)(2)(3,2,1)(16))

function add(a) {
    let curry = (b) => {
        a += b
        return curry;
    }
    curry[Symbol.toPrimitive] = (hint) => {
        return a;
    }
    return curry
}

console.log(+add(1)(2)(3)(4)(5));        // 15
console.log(+add(6)(6)(6));              // 18
console.log(+add(7)(0));                 // 7
console.log(+add(0));                    // 0