Playground: Crea un Closure para Sumar

Sí sí, muy lindo el ejercicio pero en la clase pasada de clousure ni siquiera se explicó que las funciones podrían tener un segundo parametro que iría a una función interna, tuve que ver los ejercicios de los demás para comprender. Definitivamente no creo ser el único que piense que NO está suficientemente explicado y que lo que llevamos hasta este punto no tiene la relación necesaria para que nosotros entendamos como solucionar el ejercicio satisfactoriamente.

export function sumWithClosure(firstNum = 0) {
  return function (secondNum = 0) {
    return firstNum + secondNum
  }
}

Esta interacción con las clases es lo Mejor que pudo haber inventado Platzi 💚💚💚

Posiblemente este de más la declaración de variables, pero es para que lo comprenda mejor 😁

function sumWithClosure(firstNum) {
    let a = firstNum;
    return function (secondNum) {
        let b = secondNum;
        if (!b) {
            return a;
        } else{
            return a + b;
        }
    }
}

Muy bueno el manejo de ejercicios, no lo había visto en ningún otro curso hasta ahora 😃
Esta es mi solución

export function sumWithClosure(firstNum) {
  return function (secNum) {
    return firstNum + (secNum ?? 0);
  }
}

sumWithClosure(2)(3);

export function sumWithClosure(firstNum) {
  function anidado(secondNum) {
    if (secondNum) {
      return secondNum + firstNum;
    }
    return firstNum;
  }
  return anidado;
}

Mi solución:

export function sumWithClosure(firstNum) {
  return function (secondNum = 0) {
    return firstNum + secondNum;
  }
}

super bien vale Platzi Evolucionando

Javascript es pro, o yo soy pro XDDD

export function sumWithClosure(firstNum) {
  return (secondNum = 0 ) => firstNum + secondNum 
}

Aquí la solución en una sola línea de código para los más experimentados.

export const sumWithClosure = (firstNum) => (secN = 0) => firstNum + secN

Mi solución:

export function sumWithClosure(firstNum) {
  let num = firstNum
  return function (secondNum) {
    let num2 = secondNum
    return num2 ? num + num2 : num
  }
}

Otra forma para evitar el if:

function sumWithClosure(firstNum) {
  return function sum(secondNum = 0) {
    return firstNum + secondNum;
  }
}

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  return function (secondNum) {
    console.log(secondNum)
    if (secondNum) {
      return firstNum + secondNum
    } else {
      return firstNum
    }
  }
}

Esta es mi solución:

export function sumWithClosure(firstNum = 0) {
  function sum(secondNum = 0) {
    return firstNum + secondNum;
  }
  return sum;
}

Recién

function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  let numLeftover = 0
  const sum = (secNum) => {
    if (!secNum) {
      numLeftover += firstNum
    } else {
      numLeftover = secNum + firstNum
    }   
    return numLeftover
  }
  return sum
}

estoy comenzando, pero esta es mi solución

Comparto la documentación oficial que me ayudó a resolverlo:
Closures JavaScript MDN

function sumWithClosure(a) {
  return function(b) {
    if (b === undefined) {
      return a;
    } else {
      return a + b;
    }
  };
}

Explicación:
.
La función sumWithClosure toma un número a como parámetro y devuelve otra función que toma un número b como parámetro. Si no se proporciona un segundo número, la segunda función devuelve el primer número a. Si se proporciona un segundo número, la segunda función devuelve la suma de a y b.

Para llamar a la función y obtener el resultado, podemos hacer lo siguiente:

console.log(sumWithClosure(2)(3)); // Output: 5
console.log(sumWithClosure(90)()); // Output: 90

En el primer ejemplo, se llama a la función sumWithClosure con el primer número 2, y luego se llama a la función devuelta con el segundo número 3. La función devuelta suma los dos números y devuelve el resultado 5.
.
En el segundo ejemplo, se llama a la función sumWithClosure con el primer número 90, pero no se proporciona un segundo número. La función devuelta devuelve el primer número 90.

No lo logro entender cómo funciona el playground. Cuando corro mi solución dentro de la consola del navegador, funciona para lo solicitado en el ejercicio.

function sumWithClosure(firstNumber, secondNumber) {
    if (typeof firstNumber !== "number") {
        console.log("Please use numbers within the argument");
    } else {
        let a = firstNumber;
        function adding() {
            if (typeof secondNumber === "number") {
                let b = secondNumber;
                result = a + b;
            } else {
                result = a;
            }
            return result
        }
        return adding();
    }
}

// Evaluating how the function works with different kind of values:
sumWithClosure(2,3)
sumWithClosure(90)
sumWithClosure("asdasd")
sumWithClosure(true)
sumWithClosure(1, "3")

… mi codigo … simple

export function sumWithClosure(firstNum) {
// Tu código aquí 👈
return (secondNum=0) => {
return firstNum + secondNum;
}
}

export function sumWithClosure(firstNum) {
return function result(secondNum) {
return secondNum ? secondNum + firstNum : firstNum
}
}

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  let a = firstNum;
  return function (secondNum) {
    let b = secondNum;
    if (!b) {
      return a;
    } else {
      return a + b;
    }
  }
}

La función sumWithClosure acepta un número como entrada y devuelve una función que acepta otro número como entrada y devuelve la suma de los dos números. La variable a se inicializa con el primer número y se utiliza en la función devuelta para realizar la suma. La variable b se inicializa con el segundo número y se utiliza para realizar la suma solo si se proporciona un segundo número. Si no se proporciona un segundo número, la función devuelta devuelve el primer número.

Dejo mi solucion por aqui
.
.
.
.
.
.
.
.
.

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  return function sum(secondNum) {
    if (secondNum) {
      return firstNum + secondNum
    } else {
      return firstNum;
    }
  }
}

me obsesione en que pasaria si el primero numero no era valido y si los dos no eran validos, mi aporte

function sumWithClosure(firstNum) {
    return function sumSecondPart (secondNum) { 
    if (firstNum && secondNum) {
       return firstNum + secondNum
    }
    else if (!firstNum && !secondNum) {
       return 'NOT VALID'
    }
    else if (!firstNum) {
       return secondNum
    }
    else if(!secondNum) {
       return firstNum
    }
   sumSecondPart();
 }
}
sumWithClosure()();

Alli una salucion no sera las mas optima
.
.
.
.
.
.

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  const a1 = firstNum;
  return function suma(firstNum) { 
    let result = a1;
    if (firstNum != null) { 
      result +=firstNum
    }
    return result;
  }
}

sumWithClosure(firstNum) {
// Tu código aquí 👈
function suma(secondNum = 0) {
return firstNum + secondNum
}
return suma
}

sumWithClosure(9)(3)

En mi caso yo segui la practica que hemos llevado a cabo en las demas clases de hacer return fuera y depues de la funcion para traerla y no directamente en la funcion.

Creo que lo resolví bastante bien

export function sumWithClosure(firstNum) {
  function sum(secondNum = 0) {
      return firstNum + secondNum
  }
  return sum
}
sumWithClosure(2)(3);
sumWithClosure(90)();

Me tardé algo en recordar porque el doble paréntesis, pero para eso esta Google jaja.

Se acepta Feedback

Hola equipo, pos a mi me salió así el ejercicio:

function sumWithClosure(firstNum) {
  return function (secondNumb) {
    return firstNum + secondNum;
  };
};

En realidad estaba un poco difícil de darse cuenta que una función puede retornar otra función y con ellos aceptar dos parámetros. Pero lo tome como un reto y lo logre. No esta imposible

export function sumWithClosure(a) {
    function sum(b) {
      if (a && !b)
        return a;
      else if (!a && b)
        return b;
      else
        return a + b
    };
    return sum;
};

Por acá comparto mi desarrollo.
.
.
.
.
.
.
.
.
.

export function sumWithClosure(firstNum) {
// Tu código aquí 👈

return function seconNumber(number)
{
let result = number == null ? firstNum:firstNum + number
return result
}

}

Me salió despues de un rato pensandolo pero pienso que debe haber forma de optimizar esto sin usar tanto if else, si de casualidad los saben les agradecería por sus aportes

export function sumWithClosure(firstNum) {
  return function (secondNum) {
    if (!firstNum) {
      return secondNum;
    }
    else if (!secondNum) {
      return firstNum;
    } else {
      return firstNum + secondNum;
}}}

Mi codigo.
.
.
…
.
.
…
.
.
.
.
.
.
export function sumWithClosure(firstNum) {
// Tu código aquí 👈
return function segundo(second = 0) {
return firstNum + second
}

}

mI versión se baso en el ejemplo de:
function contador ( i ) {
sale mas facil si se toma como base ese ejemplo:

  let acumulador = firstNum

  function aumentar(i2) {

    if (i2 != undefined) {
      acumulador = i2 + firstNum;
      return acumulador;
    } else {
      return firstNum;
    }
  }
  return aumentar;

Luego de analisar los ejercicios de los compañeros, saque mi propia version de la solucion.

Mi código.

export function sumWithClosure(firstNum = 0) {
  // Tu código aquí 👈
  function suma(secondNum = 0) {
    return (firstNum + secondNum);
  }
  return suma;
}

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈 
  function plus(secondNum) {
    if (secondNum !== undefined) {
      return firstNum + secondNum;
    } else {
      return firstNum;
    }
  }
  return plus;
}
sumWithClosure(2)(3);

mi solución

export function sumWithClosure(firstNum) {
  return function second(secondNum) {
    if (secondNum) {
      return firstNum + secondNum
    } else {
      return firstNum
    }
  }
}

Por aca dejo mi respuesta:
//
//
//
//
//
//
//
//
//
//
//
//
//
//

export function sumWithClosure(firstNum) {
  return function (secondNum) {
    if (!secondNum) {
      return firstNum;
    } else {
      return firstNum + secondNum;
    }
  }
}
sumWithClosure()

export function sumWithClosure(firstNum) {
  return function secondSumWithClosure(secondNum = 0) {
    let result = firstNum + secondNum;
    return result;
  }
}

Se exporta la función sumar con clousure, se recibe el primer parámetro, pero creamos un clousure al retornar una función dentro de una función, y por parámetro asignamos sin declarar una variable global, al retornar la suma, se ejecuta correctamente la suma de los parámetros.

export function sumWithClosure(firstNum) {
  return function(secondNum = 0) { 
    return firstNum + secondNum
  }
}

sumWithClosure(2)(3)

Este tipo de ejercicios son muy didacticos.

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  const sum = (secondNum=0) => { 
    return firstNum + secondNum
  }
  return sum
}
sumWithClosure(2)(3);

Pues si me salió, pero tuve que googlear, me hubiera gustado que me explicarán que se podía hacer ese tipo de función y hubieran puesto un ejercicio de lo más básico a este

Hola, dejo mi solución al ejercico…
Me gusto mucha esta clase interactiva, es la primera vez que las uso 🤩

export function sumWithClosure(firstNum) {
  return function numberTwo(secondNumber) {
    secondNumber === undefined ? 0 : secondNumber;
    return validateUndefined(firstNum) + validateUndefined(secondNumber);
    function validateUndefined(number) {
      return number === undefined ? 0 : number
    }
  }
}

Acepto feedback ✨

Como hice mi ejercicio, aunque falle una vez, porque me olvide que si no se le pasa el parametro da error.

export function sumWithClosure(firstNum = 0) {
  return (number = 0) => number + firstNum;
}

¿Sabias que puedes guardar funciones en una variable?
Ya sea var, let ó const te dejo mi ejemplo con una constante y función asignada 😎

export function sumWithClosure(firstNum = 0) {
  const sumar = function (secondNum = 0) {
    return firstNum + secondNum
  }
  return sumar
}

Agrege una funcion que trae un numero aleatorio (fije el rango en 0 y 99 pero se puede cambiar) y llamo en el primer console.log al valor firstNum mientras que en el segundo console.log (el return) llamo a la suma de firstNum+secondNum

function getRandomInt(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min) + min);
}

function sumWithClosure(firstNum) {
    console.log(firstNum);


    function parent(secondNum) {
        console.log(firstNum+secondNum)
    }

    return parent(getRandomInt(0, 99))
}
return sumWithClosure (getRandomInt(0, 99))

Se me complico un poco al principio, pero esta es mi solución

Al principio se me complico comprender, ya que decía textualmente “recibirás dos números aleatorios por parámetros” y yo pensaba que la función inicial era la que recibía los dos numero aleatorios, pero revisando el input, me di cuenta que ese segundo numero lo recibía la segunda función y lo hice de esta manera:

Antes resuélvelo
…
…
…
…
…
…
…
…
…
…
…
…

export function sumWithClosure(firstNum) {
  return (seconNum = 0) => {
    return seconNum + firstNum; 
  }
}

Hola compañeros, la verdad me costo mucho trabajo este ejercicio, les comparto mi solución, ojala les ayude.

mi solucion

My solution

export function sumWithClosure(firstNum) {
  const secondNum = 0;

  function sumar(secondNum) {
    if (secondNum) {
      return parseInt(firstNum) + parseInt(secondNum);
    }
    return firstNum
  }
  return sumar
}

Mi solución al desafío:

Esta es mi solucion, te la explico

export function sumWithClosure(firstNum) {
  return function sumW(secNum = 0) {
    return firstNum + secNum;
  }
  // Tu código aquí 👈
} 

Tenemos la funcion sumWithClousure que recibe el primer numero, esta misma retorna otra funcion llamada sumW, aqui se crea una clausura por la funcion interna (sumW) la cual tiene acceso a firstNum y secNum
Entonces si llamo a sumWithClousure y solo le envio un valor entendera que el valor del segundo es 0, por eso el secNum=0 en la clousure y este retornara la suma de ambos numeros.

EZ

export function sumWithClosure(firstNum) {
  return function (secondNum) {
    return  firstNum + secondNum || firstNum
  }
}

gg

Aqui mi solucion

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  return function sumDos(secNum = 0) {
    return secNum + firstNum;
  }
}

❤️🤩

function sumWithClosure(firstNum) {
    let x = firstNum;

    function sum(secondNum) {
        let y = secondNum;

        if (x === undefined) {
            x = 0;
        } else if (y === undefined) {
            y = 0;
        }
        
        return x + y;
    }
    return sum;
  }

MI solución :

function sumWithClosure(firstNum) {
  return function secondNumber(secondNum) {
    if (!secondNum) {
      return firstNum;
    } else {
      return firstNum + secondNum;

    }
  }

}

function sumWithClosure(firstNum, secondNum) {

    let first = firstNum
    let second = secondNum

    if (second > 0) {
        function secondNumber () {
        result = first + second
            console.log(result)
        }

        return secondNumber()

    }
    else {
        console.log(first)

    }

}

sumWithClosure(10, 20);

Usé operador ternario.

export function sumWithClosure(firstNum) {
  return function conditionalSum(secondNum) {
    return (secondNum) ? firstNum + secondNum : firstNum;
  }
}

export function sumWithClosure(firstNum = 0) {
  return function sumSecond(secondNum = 0) {
    return firstNum + secondNum  
  }
}

export function sumWithClosure(num1) {
  return function (num2) {
    if (num2 === undefined) {
      return num1;
    }
    return num1 + num2;
  }
}

Se me hizo difícil, pero lo resolví así.

function sumWithClosure(firstNum) {
    let num1 = firstNum
    function sumar(firstNum) {
        if (!firstNum) {
            return num1
        } else {
            return num1 + firstNum
        }
    }
    return sumar
  }

Mi solucion en 1 sola linea de codigo.

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  return (secondNumber) => secondNumber ? firstNum + secondNumber : firstNum
}

Mi Solucion

function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  return (secoundNum) => firstNum + (secoundNum || 0);
}

Dejo mi solución:

export function sumWithClosure(firstNum) {
  let first = firstNum
  return function sumWithClosure(secondNum) {
    let second = secondNum
    if (second === undefined) {
      return first
    } else {
      return first + second
    }
  }
}

Trate de ser lo mas literal posible con el ejercicio

export function sumWithClosure(firstNum) {

  function sumWithClosure(secondNum) {
    if (!secondNum) {
      return firstNum
    }
    else {
      return firstNum + secondNum
    }
    
    
  }
  return sumWithClosure
}

function accumulations(accumulator=0){
    let num1 = accumulator;
    return function accumulating(num2 = 0){
        return num1 = num1 + num2;
    }
}
const accum = accumulations();

Mi solucion

Excelente los ejercicios que meten entre clases. Les comparto mi solución.

export function sumWithClosure(firstNum) {
  let num = firstNum;
  return (secondNum) => num += (secondNum || 0);
}

export function sumWithClosure(firstNum) {
  function somnumer(segudoNumero) {
    if (segudoNumero == undefined) {
      segudoNumero = 0
    }
    return firstNum+segudoNumero
  }
  return somnumer
}

me toco cacharrear codigo ageno, no sabia que se tenia que hacer un return a la funcion anidada,

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈



  const suma = (second) => {
    if (second === undefined) {
      return firstNum 
    }
    return firstNum + second
    
  }
    return suma
}

export function sumWithClosure(firstNum) {
  return (secondNum = 0) => firstNum + secondNum;
}

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  function suma(secondNum=0) {
    return firstNum + secondNum;
  }
  return suma;
}

export function sumWithClosure(firstNum) {
  return function (secondNum) {
    if (secondNum) {
      return secondNum + firstNum;
    }
    return firstNum;
  };
}

export function sumWithClosure(firstNum) {
  const num1 = firstNum | 0;

  return function (secundNumber) {
    const num2 = secundNumber | 0;

    return num1 + num2;
  }
}

export function sumWithClosure(firstNum) {
  let numA = firstNum;

  return function (secondNum = 0) {
    let numB = secondNum
    return numA + numB;
  }
}

function sumWithClosure(firstNum) {
  let num1 = firstNum
  function sumar(secondNum) {
    let num2 = secondNum || 0
    return num1 + num2;
  }
  return sumar;
}

Para los que se preguntaron como por que no retornar la funcion sumar() con parentesis:

La función sumar() no se llama con paréntesis en la función sumWithClosure() porque se está devolviendo por sumWithClosure(). Esto significa que el valor de retorno de sumWithClosure() es la función sumar() en sí, no el resultado de llamar a la función sumar().

En otras palabras, sumWithClosure() está devolviendo una referencia a la función sumar(), por lo que cuando llames a sumWithClosure(), podrás llamar a la función devuelta pasándole un argumento. Por eso es necesario llamar a la función devuelta con paréntesis, como en este caso: sumWithClosure(2)(3).

El uso de closures en este caso permite la creación de una variable privada (num1) que puede ser accedida por la función sumar(), pero no es accesible directamente desde fuera de la función sumWithClosure(). Esto te permite guardar el valor del primer número y usarlo cuando se llama a la función devuelta para agregar el segundo número.

Mi solución:

export function sumWithClosure(firstNum) {
  return function (secondNum) {
    return (!secondNum) ? firstNum : firstNum + secondNum;
  }
}

Mi solución

export function sumWithClosure(firstNum) {
  return (secondNum) => 
    secondNum ? firstNum + secondNum : firstNum;
}

sumWithClosure(2)(3)

<code> 
function sumWithClosure(firstNum=0) {
  // Tu código aquí 👈
  function functionDos(secondNum=0) {
    return (firstNum + secondNum);
  }

  return functionDos
}

sumWithClosure(2)(3)

Yo hice de esta forma y salió un poco más corto.

<code> 

function sumWithClosure(firstNum) {
    function sumaDosNumeros(secondNum = 0) {
      return (firstNum + secondNum);
    }
    return sumaDosNumeros;
}

sumWithClosure(3)(2);
sumWithClosure(3)();

Mi solución:

export function sumWithClosure(firstNum=0) {
  function innerSum(secondNum=0) {
    return firstNum + secondNum
  }
  return innerSum
}

La manera mas rapida para mi es utilizar un arrowFunction:

function sumWithClosure(firstNum) {
  return (secondNum) => {
    if (!secondNum) {
      secondNum = 0;
    }
    return firstNum + secondNum;
  }
}

export function sumWithClosure(firstNum) {
    return function numberTwo(secondNumber)
    {
      if (secondNumber)
      {
        return secondNumber + firstNum;
      }
      else
      {
        return firstNum;
      }
    }
  }
  console.log(sumWithClosure(90)());

Aquí la forma en que lo hice

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  let firstNumber = firstNum;
  return function (secondNum=0) {
    const secondNumber = secondNum;
    return firstNumber + secondNumber;
  }
}

Les comparto mi solución:

export const sumWithClosure =
  (firstNum) => (secondNum) => ((firstNum || 0) + (secondNum || 0))

Podemos observar dos arrow functions anidadas con return implicito, la primer arrow function retorna una segunda función y la segunda función retorna la suma de los dos parametros validando de que existan caso contrario tome el valor de 0 .

export function sumWithClosure(firstNum) {
  function suma(secondNumber = 0) {
    return firstNum + secondNumber;
  }
  return suma;
}

function sumWithClosure(firstNum) {
  const a = firstNum;

  return function (second) { 
    let b = second
    if (!b) {
      return a;
    }else if (!a){
        return b ;
    } else { 
      return a + b;
    }
  }
}

Yo he encontrado esta solución. Inicializar el segundo valor a 0 por defecto me parece interesante y reduce lógica ya que puedo eliminar la condición. Espero resulte de ayuda al resto.

export function sumWithClosure(firstNum) {
  return function (secondNum = 0) {
      return secondNum + firstNum;
  };
}

Años en platzi y primera vez que veo esto. Se nota el crecimiento de la plataforma.