无法在JavaScript中编写add方法

Unable to write add method in JavaScript

本文关键字：add 方法 JavaScript      更新时间：2023-09-26

如何编写add函数，以便我们可以将其称为

add(3,5);
// and 
add(3)(5);
在JavaScript

吗?

这里有一种通用的方法来curry 任何函数，只要它定义了所有的形式参数(即它不能与可变函数一起工作)。

function curry(f) {
    return function() {
        if (arguments.length >= f.length) {
            return f.apply(null, arguments);
        }
        var args = Array.prototype.slice.call(arguments, 0);
        return curry(f.bind.apply(f,[null].concat(args)));
    }
}

它的工作原理是将函数接受的参数数量(通过.length属性公开)与传递给函数的参数数量进行比较。如果传递给函数的实参少于函数接受的实参，则返回一个带有绑定形参的新函数。

用法:

function add(a, b, c) {
    return a + b + c;
}
add = curry(add);
console.log(add(1,1,1));   // 3
console.log(add(1,1));     // function
console.log(add(1,1)(2));  // 4
console.log(add(1)(2,2));  // 5
console.log(add(1)(2)(3)); // 6

演示:http://jsfiddle.net/90zs4n92/

可以在这里找到一个避免绑定参数的替代实现。

这是基于我原来的评论的解决方案。顺便说一下，我看到每个人都有相同的想法(返回一个function对象)。

var add = (function(x, z) {
    return (typeof(z) !== "undefined") ? x + z : function(y) { return x + y; }
});
var value = add(3)(5);
alert(value); // 8
value = add(3, 5);
alert(value); // 8

如果你的问题的最初目标是关于柯里化，我发现一个有趣的文档，使用JavaScript: https://medium.com/@kbrainwave/curryingin -javascript-ce6da2d324fe

也许这就是你想要的?

function addFactory(a) {
  return function(b) {
    return a + b;
  };
}
//Make an addingFunction
var addThree = addFactory(3);
addThree(5);  // returns 8
//Or, in short
addFactory(3)(5);  // returns 8

您可以通过检查arguments.length和参数的类型，使函数处理add(3,5)和add(3)(5)的情况。然而，我想如果只有两个函数和一个if语句，会更容易读懂。不知道你用它做什么

这两种方法都可以:

add = function(a, b) {
    if(b === undefined) {
        return function(b) {
            return add(a, b);
        }
    }
    return a + b;
}
alert(add(3)(5));
alert(add(3, 5));

您想要编写一个可curryable函数—一个接受n数量的参数的函数，但是如果您不使用所有参数调用它，它将返回一个部分应用的函数。

var add = function(a, b) {
    if(arguments.length === 2) {
        return a + b;
    }
    else {
        return function(x) { return x + a }
    }
}
var addFour = add(4); 
add(4, 3); // => 7
add(4)(3); // => 7
addFour(3); // => 7

试试这个

function add() {
   //Check the number of arguments
   var argLength = arguments.length;
   //No arguments
   if(argLength == 0) {
      return null;
   }
   //Only one argument, then return another function. 
   if(argLength == 1) {
      var first = arguments[0];
      return function(second) {
         return first + second;
      }
   }
   //More than one argument, then add them all.
   var output = 0;
   for(var i = 0; i < argLength; i++) {
      output += arguments[i];
   }
   return output;
}

你可以这样做:

   function add(a, b) {
    if(b === undefined || arguments.length !== 2) {
        return function(b) {
            return add(a, b);
        }
    }
    return a + b;
}
alert(add(3)(5));
alert(add(3, 5));

套用是指将接受多个参数的函数分解为一系列只接受部分参数的函数。Scheme

中的示例
(define (add a b)
(+ a b))
(add 3 4) returns 7

这个函数接受两个参数a和b，并返回它们的和。现在我们将curry这个函数:

(define (add a)
    (lambda (b)
        (+ a b)))`

这是一个函数，它接受一个参数a，并返回另一个参数b，该函数返回它们的和。

((add 3) 4)
(define add3 (add 3))
(add3 4)

第一条语句返回7，类似于(add 34)语句。第二个语句定义了一个名为add3的新函数，它将把3添加到它的参数中。这就是有些人所说的结束。第三条语句使用add3操作将3加到4上，结果仍然是7。

相关文章：