javascript - una - Función de suma de currículum variable

programas en javascript resueltos

Question

Necesito una función de suma js para trabajar así:

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

Oí que no se puede hacer. Pero he oído que si se puede sumar + delante de la sum se puede hacer. Me gusta +sum(1)(2)(3)(4) .
¿Alguna idea de cómo hacer esto?

Answer 1

Aquí hay otra forma funcional utilizando un proceso iterativo.

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

y una linea

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

Answer 2

Aquí hay una solución que usa ES6 y toString , similar a @Vemba

function add(a) {
let curry = (b) => {
a += b
return curry
}
curry.toString = () => a
return curry
}
console.log(add(1))
console.log(add(1)(2))
console.log(add(1)(2)(3))
console.log(add(1)(2)(3)(4))

Answer 3

Este es un ejemplo del uso de corchetes vacíos en la última llamada como clave de cierre (de mi última entrevista):

suma (1) (4) (66) (35) (3) ()

function sum(numberOne) {
var count = numberOne;
return function by(numberTwo) {
if (numberTwo === undefined) {
return count;
} else {
count += numberTwo;
return by;
}
}
}
console.log(sum(1)(4)(66)(35)(3)());

Answer 4

Estoy publicando esta revisión como su propia publicación, ya que aparentemente todavía no tengo suficiente reputación como para dejarla como un comentario. Esta es una revisión de la excelente solución de @Rafael.

function sum (n) {
var v = x => sum (n + x);
v.valueOf = () => n;
return v;
}
console.log(+sum(1)(2)(3)(4)); //10

No vi una razón para mantener el bit v.toString, ya que no parecía necesario. Si me equivoqué al hacerlo, por favor, hágame saber en los comentarios por qué se requiere v.toString (sin mi aprobación). Convirtió el resto de las funciones anónimas en funciones de flecha para facilitar la lectura.

Answer 5

No estoy seguro si entendí lo que quieres, pero

function sum (n) {
var v = function (x) {
return sum (n + x);
};
v.valueOf = v.toString = function () {
return n;
};
return v;
}
console.log(+sum(1)(2)(3)(4));

JsFiddle

Answer 6

Otro enfoque ligeramente más corto:

 const sum = a => b => b? sum(a + b) : a;

Utilizable como:

console.log(
sum(1)(2)(),
sum(3)(4)(5)()
);

Answer 7

Para hacer que sum(1) pueda llamar sum(1)(2) , debe devolver una función.

La función puede ser llamada o convertida en un número con valueOf .

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

Answer 8

Puede hacer uso de la siguiente función

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
}

Dado que las funciones son objetos, podemos agregarle propiedades, que estamos restableciendo cuando se ha accedido.

Answer 9

Ya que esta es una pregunta de entrevista común, aquí está mi opinión sobre el uso de las propiedades de la función para agregar la memoria a la función sum () y simplificar un poco su código:

function sum(x) {
sum.result = (sum.result) ? sum.result += x : x;
sum.valueOf = function() {
return sum.result;
}
return sum;
}
sum(1)(2)(3); // == 6

Answer 10

let add = (a) => {
let sum = a;
funct = function(b) {
sum += b;
return funct;
};
Object.defineProperty(funct, ''valueOf'', {
value: function() {
return sum;
}
});
return funct;
};
console.log(+add(1)(2)(3))

Answer 11

 function sum(a){
let res = 0;
function getarrSum(arr){
return arr.reduce( (e, sum=0) => { sum += e ; return sum ;} )
}
function calculateSumPerArgument(arguments){
let res = 0;
if(arguments.length >0){
for ( let i = 0 ; i < arguments.length ; i++){
if(Array.isArray(arguments[i])){
res += getarrSum( arguments[i]);
}
else{
res += arguments[i];
}
}
}
return res;
}
res += calculateSumPerArgument(arguments);
return function f(b){
if(b == undefined){
return res;
}
else{
res += calculateSumPerArgument(arguments);
return f;
}
}
}