No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Aprende Ingl茅s, Programaci贸n, AI, Ciberseguridad y mucho m谩s.

Antes: $249

Currency
$209
Suscr铆bete

Termina en:

5 D铆as
8 Hrs
38 Min
44 Seg

Playground: Crea un Closure para Sumar

8/13

Aportes 156

Preguntas 6

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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

Estoy de acuerdo con los comentarios de que no se cubrio el tema de los dobles parentesis, o como lo encontr茅 en algunos foros 鈥渇unction 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;
  }
}

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.

```js export function sumWithClosure(firstNum) { return function sumWithClosure2(secondNum) { if (secondNum === undefined) { return firstNum; } else { return firstNum + secondNum } } } ```Quiz谩 si recien estas adentrandote en estos temas de closures, scopes, ambito lexico, etc, te encontraste con la duda de porque la funcion ped铆a dos argumentos por separado de esta manera `sumWithClosure(2)(3);`, esto no se ha dicho en el curso aun, pero esa practica se llama currying, y consiste en la idea de que una funci贸n tome un argumento y devuelva otra funci贸n que tambi茅n toma un argumento, el segundo argumento se refiere a la funci贸n anidada que devuelve la funci贸n principal. Es 煤til aplicarlo en situaciones donde deseas configurar una funci贸n con algunos valores iniciales y luego aplicarla a otros valores m谩s adelante. Es una t茅cnica poderosa para crear funciones m谩s expresivas y reutilizables.
Me parece m谩s entendible y pr谩ctico hacerlo con arrow functions. ```js const sumWithClosure = (firstNumber) => (secondNumber) => { if(secondNumber) { return firstNumber + secondNumber; } return firstNumber; } sumWithClosure()(); ```

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

La verdad tuve que consultar con ChatGPT qu茅 era eso de ejecutar una funci贸n con dos par茅ntesis pues no se nos hab铆a explicado eso, pero a煤n as铆 creo que el ejercicio fue interesante y se aprendi贸 algo nuevo que se pueden hacer con los closures. Aqu铆 mi soluci贸n: ```js export function sumWithClosure(firstNum) { return function sumWithClosure(secondNumber) { if (secondNumber) { return firstNum + secondNumber; } else { return firstNum; } }; } ``` ![](https://static.platzi.com/media/user_upload/Screenshot%202024-04-25%20115305-32e644d6-44d2-4048-af75-faf1ffea0eb4.jpg)
`export function sumWithClosure(firstNum) { ` `// Retornamos una funci贸n closure que toma el segundo n煤mero como argumento. return function (secondNum) { // Verificamos si el segundo n煤mero est谩 definido. ` `// Si no lo est谩, simplemente retornamos el primer n煤mero. ` `if (secondNum === undefined) { ` `return firstNum; ` `} ` `// Si el segundo n煤mero est谩 definido, retornamos la suma de ambos n煤meros. ` `return firstNum + secondNum; ` `};}` `console.log(sumWithClosure(2)(3)); //Output: 5` `console.log(sumWithClosure(90)()); //Output: 90`
```js export function sumWithClosure(firstNum) { function makeSum(secondNumber) { return (firstNum || 0) + (secondNumber || 0) } return makeSum } ```Esta es mi soluci贸n, sin embargo estoy muy de acuerdo con que esto no es como tal un ejercicio de clousure, este m茅todo se conoce como currying y es un nombre abreviado para una recursi贸n de funciones anidadas <https://javascript.info/currying-partials> ac谩 les dejo para que lean m谩s de el.
```js export function sumWithClosure(firstNum) { //El intento: return function sumWithClosure2(secondNUmber) { if (firstNum === undefined || secondNUmber === undefined) { return 0 + firstNum || secondNUmber; } else { return firstNum + secondNUmber; } } } ```export function sumWithClosure(firstNum) { 聽 return function sumWithClosure2(secondNUmber) {聽 聽 if (firstNum === undefined || secondNUmber === undefined) {聽 聽 聽 return 0 + firstNum || secondNUmber;聽 聽 } else {聽 聽 聽 return firstNum + secondNUmber;聽 聽 }聽 } }
No sabia que de esta manera se pod铆a llamar una funci贸n dentro de otra ```js export function sumWithClosure(firstNum) { // Tu c贸digo aqu铆 馃憟 return function (secondNum) { return (firstNum ?? 0) + (secondNum ?? 0); } } ```export function sumWithClosure(firstNum) {聽 // Tu c贸digo aqu铆 馃憟聽 return function (secondNum) {聽 聽 return (firstNum ?? 0) + (secondNum ?? 0);聽 }}
Mi soluci贸n ```js export let sumWithClosure = (firstNum) => (secondNumber = 0) => firstNum + secondNumber; ```export let sumWithClosure = (firstNum) => (secondNumber = 0) => firstNum + secondNumber;
mi solucion luego de un dia interiorisando los conceptos y 1 hora de videos en youtube y varias lecturas en [MDN Web Docs (mozilla.org)](https://developer.mozilla.org/en-US/).... `export function sumWithClosure(firstNum) {聽 let a = firstNum;` `聽 return function sum(secondNum) {聽 聽 let b = secondNum;聽 聽 if (!b) {聽 聽 聽 return a;聽 聽 }聽 聽 else {聽 聽 聽 return a + b;聽 聽 }聽 聽 }}`
```js export function sumWithClosure(firstNum) { function secondNum(secondNum = 0) { return firstNum + secondNum; } return secondNum } ```export function sumWithClosure(firstNum) { function secondNum(secondNum = 0) { return firstNum + secondNum; } return secondNum}
Estoy de acuerdo con el compa帽ero, el tema no quedo claro, por lo que una vez mas, Youtube fue mas eficiente que este curso de platzi para profundizar en el tema. Despu茅s de practicar un poco en visual estudio, aqu铆 mi soluci贸n: ```js export function sumWithClosure(firstNum = 0) { function local(secondNum = 0) { return firstNum + secondNum } return local } ```
Ac谩 retornando solo una funci贸n an贸nima donde comprueba si alguno es undefined. ```js export function sumWithClosure(firstNum) { return (secondNum) => (firstNum !== undefined && secondNum !== undefined) ? firstNum + secondNum : (firstNum === undefined) ? secondNum : firstNum; } ```
Mi c贸digo (para poderlo hacer se requiere saber a. Closures b. Operadores L贸gicos c. Tipos de Datos c.1. C贸mo trabajan las funciones el tipo NaN. ): ```js export function sumWithClosure(firstNum) { const a = Number(firstNum || 0) function innerSum(secondNum) { const b = Number(secondNum || 0) return a + b; } return innerSum } ```export function sumWithClosure(firstNum) { 聽 const a = Number(firstNum || 0) 聽 function innerSum(secondNum) { 聽 聽 const b = Number(secondNum || 0) 聽 聽 return a + b; 聽 } 聽 return innerSum }
Mi c贸digo (para poderlo hacer se requiere saber a. Closures b. Operadores L贸gicos c. Tipos de Datos c.1. C贸mo trabajan las funciones el tipo NaN. ): ```js export function sumWithClosure(firstNum) { const a = Number(firstNum || 0) function innerSum(secondNum) { const b = Number(secondNum || 0) return a + b; } return innerSum } ```export function sumWithClosure(firstNum) { 聽 const a = Number(firstNum || 0) 聽 function innerSum(secondNum) { 聽 聽 const b = Number(secondNum || 0) 聽 聽 return a + b; 聽 } 聽 return innerSum }
Mi c贸digo (para poderlo hacer se requiere saber a. Closures b. Operadores L贸gicos c. Tipos de Datos c.1. C贸mo trabajan las funciones el tipo NaN. ): `export function sumWithClosure(firstNum) {` `聽 const a = Number(firstNum || 0)` `聽 function innerSum(secondNum) {` `聽 聽 const b = Number(secondNum || 0)` `聽 聽 return a + b;` `聽 }` `聽 return innerSum` `}`
Us茅 una funci贸n flecha para hacer el c贸digo mas limpio y no le di asignaci贸n "0" al par谩metro 1 porque el ejercicio dice que siempre lo dar谩. Se los dejo a consideraci贸n. ```js export function sumWithClosure(firstNum) { return (secNum=0) => firstNum + secNum; } ```export function sumWithClosure(firstNum) { return (secNum=0) => firstNum + secNum;}
mismo ejemplo de "Sebasti谩n Rodolfo Hern谩ndez Rodr铆guez" pero con arrow function ```js export function sumWithClosure(firstNum) { // Tu c贸digo aqu铆 馃憟 return (secondNum = 0) => firstNum + secondNum } ```export function sumWithClosure(firstNum) { // Tu c贸digo aqu铆 馃憟 return (secondNum = 0) => firstNum + secondNum }

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
    }
  }
}
```js export function sumWithClosure(firstNum) { // Tu c贸digo aqu铆 馃憟 return function inner(secondNum) { if (!secondNum) { secondNum = 0; } if (!firstNum) { firstNum = 0; } return firstNum + secondNum } } ```export function sumWithClosure(firstNum) { // Tu c贸digo aqu铆 馃憟 return function inner(secondNum) { if (!secondNum) { secondNum = 0; } if (!firstNum) { firstNum = 0; } return firstNum + secondNum }}

Ejemplo 3 CLOSURE:

_



Esto fue poco intuitivo para ser honesto

Aqui mi aporte, function sumWithClosure(*firstNum*) {聽 function sum(*secondNum*) {聽 聽 if (*secondNum*) {聽 聽 聽 return *secondNum* + *firstNum*;聽 聽 }聽 聽 return *firstNum*;聽 }聽 return sum;} ```js function sumWithClosure(firstNum) { function sum(secondNum) { if (secondNum) { return secondNum + firstNum; } return firstNum; } return sum; } ```
Esta es la soluci贸n que yo tengo: ![](https://static.platzi.com/media/user_upload/image-0f5fef26-8075-4b3d-90a1-514c6aa3137e.jpg)
esta ser铆a mi solucion: `export function sumWithClosure(firstNum = 0) {` ` let total = firstNum; function secondFunction(secondNumber = 0){` ` return total += secondNumber; }` ` return secondFunction;` `}` `console.log(sumWithClosure(2)(3));`

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

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

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鈥ntersante 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

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
}

}

undefined