No tienes acceso a esta clase

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

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Reg铆strate

Comienza en:

4D
3H
28M
30S

Playground: Crea un Closure para Sumar

8/13

Aportes 88

Preguntas 4

Ordenar por:

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

o inicia sesi贸n.

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, letconst 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 鈥渞ecibir谩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.

undefined