No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Qué son los High Order Components

12/19
Recursos

¿Qué son las High Order Functions en JavaScript?

Las High Order Functions son un concepto esencial en el mundo de la programación funcional y es importante entenderlo antes de avanzar a patrones más complejos en JavaScript. Estas funciones tienen la capacidad de devolver otras funciones. Esta característica permite un comportamiento muy flexible y potente al permitir que las funciones sean manipuladas como datos.

¿Cómo funcionan las High Order Functions?

Las High Order Functions operan devolviendo otras funciones. Un claro ejemplo implica una función HighOrderFunction que devuelve otra función llamada ReturnFunction. Ambas pueden recibir parámetros como cualquier otra función en JavaScript. Este enfoque permite un proceso en etapas donde primero llamamos a la High Order Function y luego, al recibir la función de retorno, podemos enviarle los parámetros necesarios y obtener un resultado.

function HighOrderFunction(param1) {
    return function ReturnFunction(param2) {
        return param1 + param2;
    }
}

const addFive = HighOrderFunction(5); // Guardamos el resultado en una variable
console.log(addFive(3)); // 8

¿Por qué es importante aprender sobre funciones de orden superior?

Estudiar las High Order Functions fomenta una comprensión más profunda de la programación funcional, un paradigma clave en la programación moderna. Dominar este concepto te preparará para entender frameworks y librerías de JavaScript como React, donde este tipo de funciones son fundamentales.

¿Qué son los High Order Components en React?

Una vez que comprendemos las High Order Functions, podemos adentrarnos en los High Order Components (HOC) en React. Un HOC es una función en React que toma un componente y devuelve un nuevo componente con funcionalidades adicionales. Este patrón es útil para reutilizar la lógica y mejorar la modularidad en las aplicaciones React.

¿Cómo transformamos una función de orden superior en un High Order Component?

Convertir una función de orden superior en un HOC implica que la función original devuelve un componente de React en vez de una simple función. A continuación, se representa cómo se puede construir una HOC simple:

function withExtraProps(WrappedComponent) {
    return function EnhancedComponent(props) {
        return <WrappedComponent extraProp="valor" {...props} />;
    }
}

¿Cómo se aplican las High Order Components en la práctica?

El uso de HOCs es extensivo y permite añadir dinámicamente propiedades o comportamientos a componentes sin modificar su implementación interna. Por ejemplo, puedes crear un HOC WithAPI que realice una petición a una API y pase los datos al componente envuelto mientras muestra un estado de carga.

function withAPI(WrappedComponent) {
    return function EnhancedComponent(props) {
        const [data, setData] = useState(null);

        useEffect(() => {
            fetch(props.apiURL)
                .then(response => response.json())
                .then(data => setData(data))
                .catch(error => console.error(error));
        }, [props.apiURL]);
        
        return data ? <WrappedComponent {...props} data={data} /> : <p>Loading...</p>;
    }
}

¿Qué beneficios aportan los High Order Components a tu código?

Implementar HOCs en tu proyecto React ofrece múltiples beneficios:

  • Reutilización de código: Permiten compartir lógica común entre componentes.
  • Composición: Posibilitan la creación de componentes más complejos al combinarlos.
  • Inyección de propiedades: Simplifican el paso de propiedades mediante la encapsulación.

El potencial de los HOCs es ilimitado, desde cargadores de datos de API hasta gestión de usuarios y más. La flexibilidad que ofrecen hace que sean herramientas poderosas y valiosas en el desarrollo de aplicaciones modernas.

Consejo para continuar aprendiendo

Aprovecha el poder de las High Order Functions y los HOCs para crear aplicaciones más limpias, estructuradas y escalables. No olvides profundizar en los fundamentos de JavaScript antes de saltar a frameworks más complejos, ya que tener una base sólida te permitirá explotar al máximo estas herramientas. ¡Sigue aprendiendo y experimentando!

Aportes 37

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

12.-Qué son los High Order Components


Las funciones como las conocemos pueden devolvernos un valor en sus returns, pero estas funciones de “orden superior”, son funciones que devuelven otras funciones.


Si llamamos a la high order function y le enviamos un parámetro no tendremos todavía un resultado, como está devolviendo otra función tenemos que llamar a esa función que obtenemos luego de llamar a la de orden superior, enviarle los nuevos parámetros que necesita la función de retorno y entonces si, obtendremos nuestro resultado.

Ok, veo en varios comentarios que hay confusion entre las HOF y los closures.
.

Para empezar tratando de resolver la duda, no son lo mismo.
Son conceptos diferentes.
Pueden llegar a trabajar juntos muchas veces pero como mencioné, son conceptos individuales.

.
Antes hay que entender que es una first class function.
Los lenguajes con funciones de primera clase (first class functions) tratan a las funciones como si fueran variables. Es por eso que en JS nosotros podemos guardar funciones en variables, etc. Usarlas como cualquier otro valor.

.
Ahora, las funciones de orden superior (high order functions) son simplemente funciones que retornan una función, que toman una función como argumento, o ambas. Es decir que aprovechan las ventajas de las first class functions (que se pueden pasar como parametro y demas).
.

Y los closures son como en JS las funciones pueden ‘recordar’ o alcanzar las variables que fueron declaradas en el ambito en el que la misma function fue retornada.
Es decir pueden preservar su ámbito externo dentro de su ámbito interno.
Con ambito, me refiero al scope, o contexto.

.

Ejm: Veamos la sig. funcion:

const myCounterFunc = () => {
  let counter = 0
  return () => ++counter
}

const incrementCounter = myCounterFunc();
incrementCounter() // 1
incrementCounter() // 2
incrementCounter() // 3

.

  • myCounterFunc es una high order function porque esta retornando otra funcion, la que aumenta la variable counter, y al mismo tiempo es una fisrt class function porque la puedo guardar en una variable, en este caso en incrementCounter.
  • Finalmente en incrementCounter estamos usando los closures. En esta funcion se guarda el ambito de la funcion de retorno, es decir que es capaz de recordar a la variable counter y su ultimo valor.

👩‍🔬 Qué son los High Order Components

Apuntes

  • Son funciones que retornan otras funciones aplicando el concepto funcional currying
function highOrderFunction(var1) {
	return function returnFunction(var2) {
		return var1 + var2;
	}
}

const withSum1 = highOrderFunction(1);
const sumTotal = withSum1(2);

// 3

Debido a que los componentes son funciones podemos también aplicar este concepto

// Caso base

function Componente(props){
	return <p>...</p>
}

function highOrderComponent() {
	return function Componente(props) {
		return <p>...</p>
	}
}
function highOrderComponent(WrappedComponent) {
	return function Componente(props) {
		return (
			<WrappedComponent
				{...algoEspecial}
				{...props}
			/>
		);
	}
}
  • De esta manera estamos personalizando varios aspectos del componente deseado, como:
    • Los parámetros de las funciones nos permiten configurar el componente que envuelve, las props
    • Podemos reutilizar los HOC

Ejemplos

function withApi(WrappedComponent) {
	const apiData = fetchApi('https://api.com');
	
	return function WrappedComponentWithApi(props) {
		if (apidData.loading) return <p>Loading</p>;
		return(
			<WrapperdComponent data={apiData.json} />
		);
	}
}
  • Antes de retornar el componente en sí, hace una petición y entrega al componente esa información
  • Además que podemos personalizar el estado de carga
function TodoBox(props) {
	return (
		<p>
			Tu nombre es {props.data.name}
		</p>
	);
}

const TodoBoxWithApi = withApi(TodoBox);
  • También podemos agregar más “capas” para tener más personalizaciones como por ejemplo
function withApi(apiUrl){
	return function withApiUrl(WrappedComponent) {
		const apiData = fetchApi(apiUrl);
		
		return function WrappedComponentWithApi(props) {
			if (apidData.loading) return <p>Loading</p>;
			return(
				<WrapperdComponent data={apiData.json} />
			);
		}
	}
}
function TodoBox(props) {
	return (
		<p>
			Tu nombre es {props.data.name}
		</p>
	);
}

const TodoBoxWithApi = withApi('https://api.com')(TodoBox);
  • Esto nos permite poder extender bastante su uso aplicándolo como

En caso de querer saber más acerca del concepto de currying comparto esta página de JavaScript info en español donde me pareció que el concepto esta bastante bien explicado

Creo que he pasado casi todos los cursos de JavaScript y no he escuchado, si mal no recuerdo, ‘currin’ functions por ningún lado, por favor si alguien me dice en que curso esta para ir a verlo se lo agradezco 😃.
Lo más cercano a eso son los “closures”, funciones que devuelven otras funciones y que recuerdan el valor de las variables declaradas en el ámbito léxico de la función de primer orden. Los “closures” tienen muchas aplicaciones gracias a este efecto.


Luego me puse a buscar y encontré el concepto de: función de orden superior (HOF) y es aquella que recibe una función como parámetro y retornan otra función. Evidentemente que con esta estructura es capaz de hacer lo mismo que un “closure” porque en esencia lo es.
Los componentes en React se benefician de esto al parecer por ser funciones.
Si a un componente le pasamos como parámetro otro componente( equivale a función que recibe otra función) y luego regresamos otro componente, que mediante sus propias props y las variables (con efecto closure) sea capaz de modificar el componente que se recibió antes, entonces entregamos un resultado diferente para cada componente que se le pase al HOC.


-Con esto podemos pasarle propiedades a nuestro componente (como el ejemplo de la API de la clase) algo como lo que hace el context y los hooks. (proveer props a los componentes de react).
-También podemos agregarle elementos al componente o convertirlo en hijo de otro componente.

Ni sabia que había un curso de Js funcional, no estaba en mi ruta. No confíes en mi Juan David😫 he llegado aqui sin topar ese curso, prometo ir para allá cuando termine este curso 😌

Espero que la siguiente imagen pueda explicar la relación entre los componentes en como se mueven de un lugar a otro, al igual que sus props.

Cada que Juan dice, si no has visto ese curso...y no lo tengo hecho siento que traicionó su confianza y me obliga a ir a hacerlo. Pdta No sabía que existía un curso de JS Funcional en las rutas no se encuentra, supongo que por lo que es antiguo.

Veo la clase y me saltan alertas mentales de un “callback hell” pero con HOC … abusar de ellos parece que genera codigo en diagonal y complica la lectura del mismo.

Es como si fuera un decorator extendiendo la funcionalidad de la primera instancia 🤔

En el minuto 5:50 creo que el código de ejemplo tiene un typo👇👇👇

Qué son los High Order Components

.
Para hablar de los HOC primero debemos hablar de Currying y los High Order Functions.
.
Las funciones pueden devolvernos un valor en su return, pero estas HOF devuelven otras funciones.
.

function highOrderFunction() {
	return function returnFunction() {
		return /* ... */
	}
}

.
La función highOrderFunction retorna otra función returnFunction y esta a su vez puede comportarse como una función común y corriente retornando lo que sea.
.

function highOrderFunction(var1) {
	return function returnFunction(var2) {
		return var1 + var2;
	}
}

const withSum1 = highOrderFunction(1);
const sumTotal = withSum1(2);

.
En este ejemplo, la highOrderFunction y el returnFunction pueden recibir parámetros como cualquier otra función de javascript. Pero si nos damos cuenta al llamara a la HOF y le enviamos un argumento todavía no obtendríamos algún resultado puesto que nos devuelve otra función. Entonces si llamamos a la nueva función (obtenida de llamara a la HOF) con el nuevo argumento que necesita en este caso withSum1, veremos que vamos a obtener nuestro resultado.
.
El ejemplo consiste en sumar 2 número, pero no vamos a enviar ambos argumentos a la HOF, sino que lo llamamos con el primer argumento, y el segundo lo llamamos en la función de retorno.
.
Esto es interesante, porque nos permite guardar en una variable el llamado a la HOF y luego poder llamar a esta variable las veces necesarias para completar la suma llamando a la función de retorno con cualquier otro argumento.
.

function highOrderFunction(var1) {
	return function returnFunction(var2) {
		return var1 + var2;
	}
}

const withSum1 = highOrderFunction(1);
const sumTotal = withSum1(2);

.

Currying

.
El currying es una técnica en programación funcional que implica convertir una función que toma múltiples argumentos en una secuencia de funciones que toman un solo argumento.
.
En JavaScript, esto se puede lograr de varias maneras.
.

// Función original que toma varios argumentos
function suma(a, b, c) {
  return a + b + c;
}

// Función curry para la suma
function currySuma(a) {
  return function(b) {
    return function(c) {
      return a + b + c;
    };
  };
}

// Uso de la función curry
const resultado = currySuma(1)(2)(3);
console.log(resultado); // Salida: 6

.
En este ejemplo, la función currySuma toma el primer argumento a y devuelve una función que toma el siguiente argumento b, que a su vez devuelve una función que toma el último argumento c. Esto permite llamar a la función resultante en una cadena, proporcionando un argumento a la vez.
.
El currying puede ser útil en ciertos casos, como en la creación de funciones parcialmente aplicadas o en la composición de funciones en un estilo más modular.
.

HOF vs Currying

.
Las funciones de orden superior (high-order functions) y el currying son conceptos relacionados en el ámbito de la programación funcional, pero no son lo mismo.
.
Funciones de Orden Superior (High-Order Functions):
.

  • Las funciones de orden superior son aquellas que toman una o más funciones como argumentos y/o devuelven una función como resultado.
  • Permiten tratar a las funciones como ciudadanos de primera clase, lo que significa que pueden ser pasadas como argumentos a otras funciones, retornadas como valores de otras funciones y asignadas a variables.

.

function operacionMatematica(operacion, a, b) {
  return operacion(a, b);
}

function suma(x, y) {
  return x + y;
}

function resta(x, y) {
  return x - y;
}

const resultado1 = operacionMatematica(suma, 5, 3);
const resultado2 = operacionMatematica(resta, 8, 2);

console.log(resultado1); // Salida: 8
console.log(resultado2); // Salida: 6

.
Currying:
.

  • El currying es una técnica específica que implica convertir una función que toma múltiples argumentos en una secuencia de funciones que toman un solo argumento.
  • Permite la aplicación parcial de funciones, lo que significa que puedes proporcionar algunos argumentos y obtener una nueva función que espera los argumentos restantes.

.

function currySuma(a) {
  return function(b) {
    return a + b;
  };
}

const suma5 = currySuma(5);
const resultado = suma5(3); // Salida: 8

console.log(resultado);

.
En resumen, las funciones de orden superior son un concepto más amplio que incluye cualquier función que manipule otras funciones, mientras que el currying es una técnica específica dentro de las funciones de orden superior que se centra en la transformación de funciones que toman múltiples argumentos. Ambos conceptos pueden combinarse y utilizarse en conjunto en el contexto de la programación funcional.
.

High Order Components

.
Mismo conceptos que HOF, pero puesto que los componentes también son funciones entonces podemos hacer combinaciones y experimentos muy interesantes.
.

function Componente(props) {
	return <p>...</p>;
}

function highOrderComponent() {
	return function Componente(props) {
		return <p>...</p>;
	}
}

.
En este caso retorna una función que es un componente de React.
.

function highOrderComponent(WrappedComponent) {
	return function Componente(props) {
		return (
			<WrappedComponent
				{...algoEspecial}
				{...props} 
			/>
		);
	}
}

.
Aquí podemos ver que el HOC recibe como parámetro otro componente llamado WrappedComponent por lo que nuestro componente de retorno va a poder utilizar a este WrappedComponent y darle nuevas propiedades, renderizarlo con otros componentes, mostrarlo o no dependiendo de alguna condición.
.
Por ejemplo, la HOF recibe un WrappedComponent y utiliza el componente de retorno para pasarle propiedades especiales algoEspecial aparte de su props.
.

function TodoBox(props) {
	return (
		<div prop={props.algoEspecial}>
			{props.children}
		</div>
	)
}

const TodoBoxWithSpecialProps = highOrderComponent(TodoBox);

.
Entonces podemos crear cualquier componente y si necesita una propiedad llamada algoEspecial, esta propiedad no se la vamos a tener que enviar desde el componente que esta llamando a nuestro componente que necesita esa propiedad, en este caso TodoBox.
.
Ahora vamos por envolver a TodoBox quien necesita esa propiedad especial, envolverlo o encapsularlo dentro de nuestra HOC y automáticamente va a recibir esa propiedad especial.
.
Normalmente, tendríamos un componente que llame a nuestro componentes que en este caso es TodoBox y si este necesita una cierta propiedad especial, tendríamos que enviársela desde el componente que está llamando a TodoBos por ejemplo sería el componente App.
.

App
|=> HOC
	|=> TodoBox
	|=> TodoBox

.
Pero si envolvemos nuestro componente TodoBox dentro de la función HOF o HOC, entonces ya no es necesario enviarle esa propiedad, sino que va a recibirla automáticamente solo por haber pasado por nuestro HOC.
.

function withApi(WrappedComponent) {
	const apiData = fetchApi("https://api.com");
	
	return function WrappedComponentWithApi(props) {
		if(apiData.loading) return <p>Loading</p>;
		return (
			<WrappedComponent data={apiData.json} />
		);
	}
}

.
La función withApi sigue recibiendo un WrappedComponent pero antes de retornarlo hace una petición a alguna API y entrega automáticamente toda esa información de esa API al WrappedComponent. Además mientras la API esté cargando vamos a poder mostrar un estado de carga por medio de un loading skeleton o un párrafo al respecto.
.

function TodoBox(props) {
	return (
		<p>
			Tu nombre es {props.data.name}
		</p>
	)
}

const TodoBoxWithApi = withApi(TodoBox);

.
Gracias a ello cualquier componente que necesite los datos de esa API solo va tener que pasar por el HOC withApi y va tener los datos automáticamente.
.

function withApi(apiUrl) {
	return function withApiUrl(WrappedComponent) {
		const apiData = fetchApi(apiUrl);

		return function WrappedComponentWithApi(props) {
			if(apiData.loading) return <p>Loading</p>;
			return (
				<WrappedComponent data={apiData.json} />
			);
		}
	}
}

.
Podemos envolver funciones dentro de funciones, como por ejemplo permitir a cada componente que decida cual será la URL de la API dónde cargaremos sus datos.
.

function TodoBox(props) {
	return (
		<p>
			Tu nombre es {props.data.name}
		</p>
	)
}

const TodoBoxWithApi = withApi("https://api.com")(TodoBox);

.
La implementación sigue siendo extremadamente sencilla puesto que maquetamos el componente, lo envolvemos en el HOC withApi, le enviamos la URL de la API al HOC, y luego le enviamos a nuestro componente.
.

const TodoBoxWithUser = 
	withUser(TodoBox);

const TodoBoxWithFilters = 
	withFilters(TodoBoxWithUser);

const TodoBoxWithTodos = 
	withTodos(TodosBoxWithFilters);

.
Podemos observar que se pueden hacer HOCs para darle propiedades del usuario a nuestros componentes, para darle datos filtrados de busqueda, para darle datos de TODOs persistidos en local storage, entre otros usos que queramos darle.
.
Incluso podemos usar HOCs para crear nuestros componentes, y estos envueltos en HOCs pasarselos a otros HOCs para que sigan envolviendo, inyectando propiedades y haciendo su magia.
.

withUser
|=> withTodos
	|=> Component

.
Por ejemplo si necesitamos que el componente tenga los datos de usuario y de datos de los TODOs, lo que vamos hacer es pasar primero el componente al HOC withUser y al resultado de esta lo pasamos al HOC de withTodos, obtenemos de esa manera la información de los 2 HOCs.
.

withUser
|=> withFilters
	|=> withTodos
		|=> Component

.
Por supuesto no hay límites y así seguir todo lo que queramos.

Que genio!
Muy buen concepto para cuando tenemos que pasar data a un componente ya creado.
También se puede modificar el padre del componente para enviarle la data. Pero esto afectaría la composición y reusabilidad de los componentes en sí.

Un Higher-Order Component (HOC) es una función que toma un componente de React y devuelve otro componente modificado. Es decir, un HOC es una función que envuelve a un componente para proporcionarle ciertas funcionalidades adicionales.

Los HOC permiten reutilizar la funcionalidad común en varios componentes sin tener que replicar el mismo código en cada uno de ellos. Además, los HOC permiten separar la lógica del componente de su representación visual, lo que puede facilitar la reutilización de la lógica en diferentes contextos.

Los HOC se utilizan con frecuencia en React para agregar ciertas funcionalidades comunes a los componentes, como la gestión del estado, la autenticación, el enrutamiento, el manejo de errores, entre otras. Algunos ejemplos comunes de HOC son connect en la biblioteca de gestión de estado Redux, withRouter en la biblioteca de enrutamiento React Router y withStyles en la biblioteca de estilos Material-UI.

Un ejemplo simple de un HOC podría ser el siguiente:

function withLog(Component) {
  return function(props) {
    console.log(`Renderizando el componente ${Component.name} con las props`, props);
    return <Component {...props} />;
  }
}

En este ejemplo, withLog es un HOC que toma un componente de React y devuelve otro componente que envuelve al original. El componente resultante es idéntico al original, pero con la adición de un mensaje de registro en la consola cada vez que se renderiza.

Podemos utilizar este HOC para envolver cualquier componente, por ejemplo:

const Saludo = (props) => <h1>Hola, {props.nombre}!</h1>;

const SaludoConLog = withLog(Saludo);

function App() {
  return (
    <div>
      <SaludoConLog nombre="Juan" />
    </div>
  );
}

En este ejemplo, SaludoConLog es el resultado de envolver el componente Saludo con el HOC withLog. Cada vez que se renderiza SaludoConLog, se mostrará un mensaje en la consola que indica que se está renderizando el componente Saludo con las props { nombre: ‘Juan’ }.

Un componente de orden superior (HOC por las siglas en inglés de higher-order component) es una técnica avanzada en React para el reuso de la lógica de componentes. Los HOCs no son parte de la API de React. Son un patrón que surge de la naturaleza composicional de React.


En concreto, un componente de orden superior es una función que recibe un componente y devuelve un nuevo componente.


Mientras que un componente transforma props en interfaz de usuario, un componente de orden superior transforma un componente en otro.


Esto lo extraje de la documentación oficial de react.js, si no les queda muy claro algún concepto les recomiendo leerla es verdaderamente útil.

jajajaja, me encanto el “y si lo hacemos bien!” (min: 5.40)

Currying me suena a cocina, nunca habia escuchado el termino en programación

De momento no encontre cursos de js en platzi que hablen de Currying y otras cosas, buena oportunidad para mas cursos de js.

PD: llevo 30% de la antigua escuela web de platzi y ahora es la nueva ruta de front y backen, si no hiciera otras rutas llevaria el 50%

Curso de Programación Funcional en JavaScript por Bedu - Platzi

https://platzi.com/cursos/funcional-js/

me da error 500

¿Qué es un closure? Un closure es un concepto en programación que se refiere a una función que "recuerda" el ámbito léxico en el que fue creada, incluso después de que la función haya terminado de ejecutarse. Esto significa que un closure puede acceder y hacer referencia a las variables y parámetros de la función externa en la que se declaró, incluso cuando esa función ya no está en el ámbito de ejecución. Un closure se crea cuando una función anidada (una función definida dentro de otra función) hace referencia a variables de la función externa. Estas variables capturadas por el closure se mantienen vivas en la memoria mientras el closure exista y pueda acceder a ellas. Esto permite crear funciones que retienen y manipulan datos que se mantienen privados y seguros dentro de su ámbito. Los closures son útiles en una variedad de situaciones, como la encapsulación de datos y comportamientos, la creación de funciones de fábrica, la gestión de devoluciones de llamada y la implementación de estructuras de datos como contadores y generadores. Aquí tienes un ejemplo simple de un closure en JavaScript: javascriptCopy code function crearFuncionContadora() { let contador = 0; function incrementar() { contador++; console.log(contador); } return incrementar; } const contador1 = crearFuncionContadora(); const contador2 = crearFuncionContadora(); contador1(); // Imprime 1 contador1(); // Imprime 2 contador2(); // Imprime 1 (cada contador tiene su propio estado) En este ejemplo, `crearFuncionContadora` crea una función anidada `incrementar`, que "recuerda" la variable `contador` incluso después de que `crearFuncionContadora` haya terminado de ejecutarse. Esto permite tener múltiples contadores independientes. # HOC vs Closure * Los High Order Components (HOCs) son una técnica específica de React que se utiliza para componer y extender componentes React existentes al agregar funcionalidad adicional o propiedades. Los HOCs son específicos de React y permiten extender componentes de manera eficiente. * Los closures son un concepto general en programación que se utiliza para encapsular variables y funciones en un ámbito, lo que les permite retener su estado incluso después de que la función que los creó haya finalizado. Los closures son una característica de muchos lenguajes de programación y no están limitados a React.

Si quieren repasar el concepto de currying más detenidamente, les recomiendo este video… (g)old

Las “High Order Functions” son funciones que pueden tomar otras funciones como argumentos y/o devolver otras funciones como resultados. Esto puede sonar un poco complicado, pero en realidad es bastante sencillo. Una forma de entenderlo es pensar en una función que hace una pizza. Una pizza es una comida deliciosa que tiene muchos ingredientes diferentes, como la salsa, el queso y los vegetales. Una “High Order Function” sería como un chef que puede tomar diferentes ingredientes y combinarlos para hacer una pizza deliciosa. De la misma manera, una “High Order Function” en programación puede tomar otras funciones y combinarlas para hacer cosas interesantes.

Mucha programación funcional en React. Me gusta!

function highOrderFunction(var1) {
  return function returnFunction(var2) {
    return var1 + var2;
  }
}

const withSum1 = highOrderFunction(1);
const sumTotal = withSum1(2);

//---------------------------------------------------------

function highOrderComponent(WrappedComponent) {
  return function Componente(props) {
    return (
      <WrappedComponent
        {...algoEspecial}
        {...props}
      />;
    );
  }
}

//--------------------------------------------------------

function withApi(WrappedComponent) {
  const apiData = fetchApi('https://api.com')

  return function WrappedComponentWithApi(props) {
    if(apiData.loading) return <p>Loading</p>;

    return (
      <WrappedComponent data={apiData.json} />
    )
  }
}

¡Ey tú! Si te sientes más perdid@ que nada en esta clase es porque mínimo te saltaste 3 cursos de JavaScript antes de este y lo sabes, pecad@r 😅.
.

💻Los temas que mínimo necesitas para entender esta clase, creo yo, son:
.
1. Scope.
2. This.
3. High Order Functions.
4. Closures.
5. Currying.

.
Y en cada tema hay otros más profundos detrás que están en la Escuela de JavaScript y la Escuela de Desarrollo Web.

El uso que le veo mas cercano es cuando se tienen componentes repetitivos, por ejemplo, si quieres hacer un motor de blog. Tienes muchos elementos como titulos, subidas de imagenes, videos, parrafos, links, y quieres que transforme el post del usuario en elementos del navegador. La idea no es que el usuario escriba h1, p, canva, picture etc, sino que con un par de clicks e input del teclado pueda agregarlo. Pueden ir en una carpeta a parte y que se llamen cuando se necesite. Tambien lo veo si el usuario quiere modificar el header o el layout de su blog.

Esto tambien aplica en las closures (que se enseñan en els cursos de JS)

Considera el siguiente ejemplo:

function creaFunc() {
  var nombre = "Mozilla";
  function muestraNombre() {
    alert(nombre);
  }
  return muestraNombre;
}

var miFunc = creaFunc();
miFunc(); 

Si se ejecuta este código tendrá exactamente el mismo efecto que el ejemplo anterior: se mostrará el texto “Mozilla” en un cuadro de alerta de Javascript. Lo que lo hace diferente (e interesante) es que la función externa nos ha devuelto la función interna muestraNombre() antes de ejecutarla.

Puede parecer poco intuitivo que este código funcione. Normalmente, las variables locales dentro de una función sólo existen mientras dura la ejecución de dicha función. Una vez que creaFunc() haya terminado de ejecutarse, es razonable suponer que no se pueda ya acceder a la variable nombre. Dado que el código funciona como se esperaba, esto obviamente no es el caso.

La solución a este rompecabezas es que miFunc se ha convertido en un closure. Un closure es un tipo especial de objeto que combina dos cosas: una función, y el entorno en que se creó esa función. El entorno está formado por las variables locales que estaban dentro del alcance en el momento que se creó el closure. En este caso, miFunc es un closure que incorpora tanto la función muestraNombre como el string “Mozilla” que existían cuando se creó el closure.

Este es un ejemplo un poco más interesante parecido al que muestra el profe : una función creaSumador:

function creaSumador(x) {
  return function(y) {
    return x + y;
  };
}

var suma5 = creaSumador(5);
var suma10 = creaSumador(10);

console.log(suma5(2));  // muestra 7
console.log(suma10(2)); // muestra 12 

En este ejemplo, hemos definido una función creaSumador(x) que toma un argumento único x y devuelve una nueva función. Esa nueva función toma un único argumento y, devolviendo la suma de x + y.

En esencia, creaSumador es una fábrica de función: crea funciones que pueden sumar un valor específico a su argumento. En el ejemplo anterior utilizamos nuestra fábrica de función para crear dos nuevas funciones: una que agrega 5 a su argumento y otra que agrega 10.

suma5 y suma10 son ambos closures. Comparten la misma definición de cuerpo de función, pero almacenan diferentes entornos. En el entorno suma5, x es 5. En lo que respecta a suma10, x es 10.

uff i’m very exciting with this course

Este concepto de verdad me gusto mucho, hay que aprenderlo a manejar pero yo creo q debe haber un consenso y una documentación por que puede llegar hacer inmanejable pasando esos parámetros

Gracias kotlin por presentarme la programación funcional de ante mano 😄

Los H.O.C me hacen acordar inevitablemente a los decorators de python 🤨

mmm esto me huele a closures de JS

A dios mio!!!

Video que explica de manera clara que es el currying
https://www.youtube.com/watch?v=3sglcKXKbyQ

Con este video se logra comprender un poco mejor:
.
https://www.youtube.com/watch?v=FuuqPqvWMv0

Entonces se podría decir que son lo mismo que los closures? 🤔