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);

Javascript es pro, o yo soy pro XDDD

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

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

super bien vale Platzi Evolucionando

Mi solución:

export function sumWithClosure(firstNum) {
  return function (secondNum = 0) {
    return 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

Comparto la opinión de mis compañeros, este es el primer ejercicio que me enfrento en un curso de Platzi que está tan confuso que es imposible de resolver si no tienes una idea más clara de lo que estamos hablando. Entiendo que es necesario siempre consultar otras fuentes para consolidar el conocimiento y entender los temas, pero diría que lo que llevamos de curso no es necesario para resolver esto, al menos NO de manera clara.

Estoy de acuerdo con los comentarios de que no se cubrio el tema de los dobles parentesis, o como lo encontré en algunos foros “function currying”. Leyendo los comentarios intenté con los scripts que aportaron y no me funcionaron, pero revisé un par de anotaciones y trate de resolverlo basandome con lo que aprendí en el curso de ECMAScript 6. Espero les sirva mi script:

export function sumWithClosure(firstNum) {
  return function mySuma(secondNum) {
    let a = firstNum ?? 0;
    let b = secondNum ?? 0;
    return a + b;
  }
}

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 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;
  }
}

Estas son las soluciones que pude hacer y entendí muy bien espero a ustedes les ayude, me parecieron muy sencillas

// solucion 1
 function sumWithClosure(firstNum) {
		function second(secondNum = 0) {
  		return firstNum + secondNum
 		}
 	return second 
	}

//solucion 2
 function sumWithClosure(firstNum) {
  	return function sum(secondNum = 0) {
			 return firstNum + secondNum
	 }
} 

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 .

Mi solución, gracias a las personas que comentaron, no conocía el operador lógico “??”

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

MI solución

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

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.

… 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
}
}

Solución al Playground

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

reto solucionado

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  return function sumN2(num2) {
    if (!num2) {
      return firstNum
    } else {
      return firstNum + num2
    }
  }
}

Ejemplo 3 CLOSURE:

_

Esto fue poco intuitivo para ser honesto

Mi solucion

export function sumWithClosure(firstNum = 2) {
  // Tu código aquí 👈
  return function (second) {
    return !!second ? firstNum + second : firstNum;
  }
}

Mi solucion

export function sumWithClosure(firstNumber) {
  // Tu código aquí 👈
  return function second(secondNumber) {
    if (secondNumber == undefined) {
      return firstNumber + 0;
    } else {
      return firstNumber + secondNumber;
    }
  };
}

intente hacerlo como en el código anterior, pero no se porque no me retorna la función parent… porque debo colocarla de esta manera

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

}

sumWithClosure(2)(3);

Me costó demasiado entender el tema, tuve que buscar fuentes externas, pero finalmente acá está mi solución.

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

Lo que había que pensar era como saber si el segundo parámetro entraba o no entraba en la función y justo para eso usamos closures, justo para que el segundo parámetro entre en la segunda función y luego con lógica dar la salida que se quería, esta es mi solución:
function sumWithClosure(firstNum)
{
function sumWithClosure(firstNum1)
{
if(firstNum1 === undefined)
{
return firstNum;
} else if(firstNum === undefined)
{
return firstNum1;
} else
{
return firstNum + firstNum1;
}
};
return sumWithClosure;
}

MI SOLUCIÓN!!!

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

Lo mejor sera ver los aportes en los comentarios, para poder entender el tema del segundo parámetro.☕✌️

<code> 
export function sumWithClosure(firstNum) {
  // 
  const num1 = firstNum;

  function addNum(secondNum) {
    const num2 = secondNum;

    if (!num2) {
      return num1;
    } else {
      return num1 + num2;
    }
  }
  return addNum;
}

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

const sum = sumWithClosure(5)

console.log(sum()) // -> 5
console.log(sum(5)) // -> 10
console.log(sum(5)) // -> 15
console.log(sum(10)) // -> 25

function sumWithClosure(a=0) {
    let resultado;
    return function suma(b=0){
        resultado = a + b;
        console.log(resultado);
        return resultado;  
    }
}  
const suma1 = sumWithClosure(2, 4);
suma1();

function sumWithClosure() {
    let firstNum = parseInt(prompt('Elige un numero: '));
  
    function sumWithClosure() {
      let secondNum = parseInt(prompt('Elige un numero: '));
      let resultado = firstNum + secondNum;
      console.log(resultado)
    }
    return sumWithClosure()
  }
  
  sumWithClosure ()()```

My solution

Hola compañeros. A mi me costó un poco loa primera vez que vi el concepto de closure. Les puede servir muchísimo el último curso del profe Facundo Martoni de Python, la sintaxis es muy similar y en él se abordan las nested functions, los closures y los decoradores. Buen refuerzo para esta clase.

Me encantan los playground de Platzi!!

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

}

Esta me quedo mas minimalista.

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

Mi respuesta:

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

mi solucion al reto

const sumWithClosure = (firstNum) => {
    if (typeof firstNum !== 'undefined') {  // Comprobamos si el primer número está definido
      return (secondNum) => {  // Devolvemos una función que toma el segundo número
        if (typeof secondNum !== 'undefined') {  // Comprobamos si el segundo número está definido
          return firstNum + secondNum;  // Sumamos el primer número y el segundo número
        } else {
          return firstNum;  // Si el segundo número no está definido, devolvemos solo el primer número
        }
      };
    } else {
      return 0;  // Si el primer número no está definido, devolvemos 0
    }
  };
  
  console.log(sumWithClosure(2)(3));   // Imprime 5
  console.log(sumWithClosure(90)());  // Imprime 90
  

Crea un Closure para Sumar

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

La diferencia entre return firstNum + secondNum; y return suma; radica en lo que se devuelve como resultado de la función sumWithClosure y cómo se puede utilizar ese resultado.

1. return firstNum + secondNum;: Esta línea de código devuelve el resultado de la suma de firstNum y secondNum. Es decir, el valor numérico resultante de la adición de ambos números. Si llamamos a sumWithClosure(5)(3), el resultado sería directamente el valor de firstNum + secondNum, en este caso, 8. Esta forma de retorno proporciona directamente el resultado de la operación aritmética.

2. return suma;: En cambio, esta línea de código devuelve la función suma como resultado. En lugar de devolver el resultado numérico de la suma, se devuelve la función en sí misma. Al llamar a sumWithClosure(5), obtenemos como resultado una función suma que puede ser invocada posteriormente. Podemos almacenar esa función en una variable y utilizarla en otros momentos. Por ejemplo, al hacer const sumar5 = sumWithClosure(5);, sumar5 será una función que suma 5 a un número dado. Luego, podemos llamar a sumar5(3) y obtendríamos el resultado de firstNum + secondNum, en este caso, 8.

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

const sumar5 = sumWithClosure(5);

Luego llamamos la funcion sumr5:

sumar5(3); // 8 (5+3)
sumar5(5); // 10 (5+5)

La diferencia clave es que en el primer caso se devuelve el resultado numérico directamente, mientras que en el segundo caso se devuelve una función que encapsula la operación de suma y que puede ser utilizada posteriormente en diferentes llamadas para realizar la suma con diferentes valores de secondNum.

Faltó contexto sobre un segundo paréntesis de la funcion

Solucion:
export function sumWithClosure(firstNum) {

function suma(second= 0) {
return firstNum + second
}
return suma

}

Me costo entender la aplicación del closure. estuve viendo la aplicación de ahorro del ejemplo anterior. Alli me oriente.
De todas maneras el instructor solo esta explica la teoría. pero pienso que debería explicarlo con ejemplo practico mas no teórico. Bueno es mi punto de vista

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

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

Esta es mi solución. Agregué una verificación para el caso en que se ingrese sólo el segundo argumento a la función y no el primero.

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

}

Ejercicio

const sumWithClosure =
  (firstValue) =>
  (secondValue = 0) =>
    firstValue + secondValue;

export default sumWithClosure;

Prueba unitaria asociada

import sumWithClosure from "../../src/closure/sumWithClosure";
describe("Unit test suite for sum with closure", () => {
  test("Should make a sum of two numbers with closure", () => {
    const expectedValue = 5;
    const firstValue = 2;
    const secondValue = 3;

    const result = sumWithClosure(firstValue)(secondValue);

    expect(result).toBe(expectedValue);
  });

  test("Should make a sum with only one value", () => {
    const expectedValue = 90;
    const firstValue = 90;

    const result = sumWithClosure(firstValue)();

    expect(result).toBe(expectedValue);
  });
});

Repo: https://github.com/zearkiatos/javascript-closures-and-scopes-kata

No tiene sentido esto.

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

Should return 113

Should return 3245

Should return 20

Should return -80

La función queda:

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

Está fue la forma en la que logre realizar el programita

export function sumWithClosure(firstNum) {
   let nada = function (secondNum) {
    return firstNum + secondNum;
    console.log('ejecutando segunda', secondNum);
   }
  return(nada)
  }

Aporto mi solución compañeros y además quiero mencionar que si investigaron para poder dar con la solución, tomaron la actitud correcta, eso es lo que se debe hacer y felicidades muchas a aquellos que lo hicieron, siéntanse orgullosos por su proceso. Hace un mes no podría haber llegado a esta solución y aprendí que frente a cada desafío de código el verdadero reto está en la investigación.
Sólo ¡NO se rindan!
.
.
.
Para esta solución utilicé el concepto de Currificación que es útil cuando en el programa que se desarrolla no se pueden proporcionar todos los argumentos a una función al mismo tiempo. Puedes guardar la llamada a cada función dentro de una variable, la cual mantendrá la referencia de la función devuelta que toma el siguiente argumento cuando esté disponible.

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

sumWithClosure();

export function sumWithClosure(firstNum) {
  function suma(secondNum) {
    let sum;
    if (!secondNum) {
      let sum = firstNum;
      return sum;
    } else {
      let sum = firstNum + secondNum;
      return sum;
    }
  }
  return suma;
}

Comparto mi solucion:

export function sumWithClosure(firstNum) {
  // Tu código aquí 👈
  let sum;
  return function (secondNum) {
    typeof secondNum !== "number" ? sum = firstNum :
      sum = firstNum + secondNum;
    return sum;
  }
} 

la explicación se queda muy corta para entender este tema, dejo un recurso que me ayudó a entender este tema.

https://github.com/getify/You-Dont-Know-JS

Aquí esta mi solución al reto:

export function sumWithClosure(firstNum) {
  return function (secondNUm) {
    if (secondNUm === undefined) {
      return firstNum;
    };
    return firstNum + secondNUm;
  };
};

Mi solución:

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

De esta manera lo solucioné, salió algo largo pero espero se entienda mejor de esa forma 💚

Acá pueden probar el código:

export function sumWithClosure(firstNumber) {
    let myNumber = firstNumber;

    function sumarNumeros(secondNumber) {
      let myOtherNumber = secondNumber;
      if (!myOtherNumber){
        return myNumber;
      }else{
        return myNumber + myOtherNumber;
      }
    }

    return sumarNumeros;
  }

Mi solución…intersante este nuevo concepto de acceder solamente por medio de la función padre a la función hija asignandole otro argumento separado en otro ()

Mi solución:

function sumWithClosure(firstNum = 0) {
    function funSuma(secNum = 0) {
      let vSuma = firstNum + secNum;
      return vSuma;
    }
    let vResult = funSuma;
    return vResult;
  }
  vClosure = sumWithClosure(2)(3);
  console.log(vClosure);
  vClosure = sumWithClosure(90)();
  console.log(vClosure);

function suma (num1=0){
function suma2 (num2=0){
return num1 + num2
}
return suma2
}
console.log(suma()(1));
console.log(suma(1)(1));
console.log(suma(3)());

//1
//2
//3

https://developer.mozilla.org/es/docs/Web/JavaScript/Closures#cadena_de_alcance_del_closure

Acá explican un poco de lo que sucede con las cadenas de ámbitos de las funciones