A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Closures en programaci贸n funcional

15/23
Recursos

Los Closures son funciones que retornan otras funciones y recuerdan el scope en el que fueron creadas, es decir, son funciones que utilizan principios de la programaci贸n funcional, no modifica el valor de variables u objetos externos, m谩s bien, utilizan sus propias variables independientes (a partir de los par谩metros que reciban estas funciones) para dar resultados correctos.

Aportes 17

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

Closures: Es una funci贸n que retorna otra funci贸n
Ejemplo:

function buildSum(a) {
	return function(b) {
		return a+b
	}
}

Y con arrow functions:

const buildSum = a => b => a+b

Y si quieren indagar un poco mas a lo que ser refiere el profesor con 鈥渟cope鈥 les dejo este post de Fanny:

Qu茅 es y c贸mo funciona el scope en JavaScript

wuaooo!! hasta el mismo profesor dice que en la entrevista le costo mucho tiempo y trabajo poder realizar ese ejercicio, vaya eso es admirable y creo que me da una lecci贸n a mi y a todos, de que a los mismos programadores expertos les cuesta mucho lidiar con el c贸digo sea b谩sico o avanzado, pero hacen lo posible por ser aprobados en una empresa, de verdad esto me alienta cuando aveces estoy frustrado.

Es un buen ejemplo, aunque no estoy de acuerdo con que los clojures son 鈥渇unciones que retornan otras funciones鈥. propiamente dicho.

Estar铆a mejor definirlo como funciones internas que tienen acceso a las variables de sus funciones externas.

Y es por esa raz贸n que en javascript las funciones que retornan funciones son tan utiles.

buildSum = a => b => a+b

console.log(buildSum(5)(5));```

Closures Arrow Function

const buildSuma = (a) => (b) => a + b```

uff esto es genial, en una de las clases anteriores no sabia muy bien que esta haciendo, pero ahora lo comprendo mejor!

Un closure

// A little closure
const buildIncrementer = (inc, num) => () => num += inc
const incrementOne = buildIncrementer(1, 5)
console.log(incrementOne()) // 6
console.log(incrementOne()) // 7
console.log(incrementOne()) // 8

Aqu铆 me gustar铆a mencionar que una de las ventajas de los closures, es que estos se quedan con el valor del scope, as铆 que nosotros podemos cambiar el valor de la primer funci贸n dentro de la segunda. Algo como lo siguiente t铆o鈥

function count(): Function {
  let startAt: number = 0;

  return (action: string): number => {
    if (action === "add") {
      startAt += 1;
    } else if (action === "remove") {
      startAt -= 1;
    }

    return startAt;
  };
}

const counter: Function = count();
console.log(counter()); // 0
console.log(counter("add")); // 1
console.log(counter("add")); // 2
console.log(counter("add")); // 3
console.log(counter("remove")); // 2
console.log(counter("remove")); // 1
console.log(counter("remove")); // 0

Pd: estoy usando TS

he usado Clousers en todo este tiempo y no sabia

Excelente, muy interesante

  • Closure: Es una funci贸n que retorna otra funci贸n adem谩s de que recuerdan el scope en el que fueron creadas.
/*Ejemplo closures */

function buildSum(a) {
    return function (b) {
        return a + b;
    };
}
const addFive = buildSum(5);
console.log(addFive(5));

Hmm, antes de ver el video trat茅 de resolverlo, pero como he trabajado mucho con esto supe como se hac铆a jaja

Por cierto, siempre cre铆 que un Closure era un callback鈥