Funciones y Componentes de Orden Superior en JavaScript y React

Clase 12 de 19 • Curso de React.js: Patrones de Render y Composición

Contenido del curso

Introducción

Composición de componentes

Render props

High Order Components

React Hooks

Próximos pasos

19
Patrones de Render en React.js: Principios y Técnicas Avanzadas
01:44 min

Tomar examen

Resumen

Comprender cómo una función puede devolver otra función es la base para dominar uno de los patrones más poderosos en React. Los high order components (HOC) permiten inyectar propiedades, datos de APIs y lógica reutilizable a cualquier componente, sin modificar su estructura interna. Todo parte de un concepto fundamental de programación funcional: el currying.

¿Qué es el currying y por qué importa en React?

Antes de hablar de componentes, hay que entender las high order functions [0:06]. Son funciones que, en lugar de devolver un valor común, retornan otra función. Esa función de retorno se comporta como cualquier función normal de JavaScript: recibe parámetros y devuelve resultados.

Un ejemplo clásico es el de la suma [0:36]:

La high order function recibe el primer número.
La función de retorno recibe el segundo número.
Solo al llamar a ambas funciones obtenemos el resultado.

Lo interesante es que podemos guardar en una variable el llamado a la primera función y reutilizarla varias veces con distintos segundos parámetros [1:06]. Esto es currying: dividir una función con múltiples parámetros en una cadena de funciones que reciben un parámetro a la vez.

Si es la primera vez que te encuentras con este concepto, es normal que resulte confuso. El currying se estudia dentro de la programación funcional [1:24], y dominarlo antes de trabajar con frameworks o librerías de JavaScript marca una diferencia enorme.

¿Cómo se convierten las high order functions en high order components?

El salto conceptual es directo: los componentes de React también son funciones [1:48]. Entonces, una función que devuelve un componente de React es un high order component.

¿Qué papel juega el wrapped component?

La clave está en que nuestra función HOC recibe como parámetro un componente, conocido como wrapped component [2:06]. El componente de retorno puede:

Pasarle nuevas propiedades al wrapped component.
Renderizarlo junto con otros componentes.
Mostrarlo o no según alguna condición.

Por ejemplo, si un componente llamado TodoBox necesita una propiedad especial, en lugar de enviársela manualmente desde el componente padre, envolvemos TodoBox dentro del HOC [2:30]. Automáticamente recibe esa propiedad solo por haber pasado por el high order component.

¿Cómo funciona un HOC con llamadas a una API?

Un caso muy práctico es crear un HOC llamado withAPI [3:18]. Esta función:

Recibe un wrapped component.
Realiza una petición a una API antes de retornarlo.
Entrega toda la información obtenida como propiedades al componente.
Mientras carga, puede mostrar un estado de carga: un párrafo, un loading skeleton o lo que necesites.

Cualquier componente que necesite datos de esa API solo debe pasar por withAPI y los recibe automáticamente [3:42].

¿Se pueden encadenar múltiples high order components?

Sí, y aquí es donde el patrón se vuelve realmente potente [3:54]. Podemos envolver funciones dentro de funciones sin límite. Algunos ejemplos prácticos:

Permitir que cada componente defina la URL de la API desde donde cargar sus datos [4:06].
Crear HOCs para inyectar propiedades del usuario, datos filtrados de búsqueda o información persistida en local storage [4:30].
Pasar un componente por withTodos, luego por withUser, y obtener la información de ambos HOCs combinada [4:48].

La implementación sigue siendo sencilla: maquetas tu componente, lo envuelves en el HOC, le pasas los parámetros necesarios y recibes todas las propiedades inyectadas de forma automática.

El encadenamiento puede extenderse tanto como lo necesites: withTodos, luego withFilters, luego withUser [5:06]. Cada HOC agrega su propia capa de datos o lógica sin que el componente original se modifique.

¿Ya habías trabajado con high order components o es la primera vez que te encuentras con este patrón? Comparte tu experiencia y las dudas que te hayan surgido.

Harold Zurita Simon

student•

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.

Nicolás Felipe Pinto Vega

student•

Muchas gracias por tus notas. Me ayudó mucho a complementar la clase y entender mejor el concepto.

Juan Pablo Jimenez

Obed Paz

Fernando Quinteros Gutierrez

Mariano Gastón Paduani

Christian Boffill

Juan Castro

teacher•

Luis Alejandro Vera Hernandez

Filiberto Santillán

Julian Franco

Jair Neri

Josmanuel Sandrea

Fabián Nava Pereda

Carlos Rodríguez

Andersson Rincon

Josue Tapia Linarez

Gerardo Castillo

Christian Rivera

Yael Diez

Josué Hernández

Abdias Jimenez

Franklin Lucero

Reinaldo Mendoza

Williams Munguía

Daniel Alberto Vega Bejarano

Funciones y Componentes de Orden Superior en JavaScript y React

Introducción

Patrones de Render en ReactJS: Mejora tu Código y Organización

Principios de Diseño de React: Filosofía y Aplicación Práctica

Composición de componentes

Composición de Componentes en React: Principios y Prácticas

Composición y Colocación de Estado en React con Patrones de Renderización

Optimización de Composición de Componentes en React

Composición Saludable con React Context en Aplicaciones React

Eliminación de React Context mediante Custom Hooks en React

Render props

Render Props y Render Functions en React: Patrones Avanzados

Render Props en React: Mejora de Componentes con Ejemplo de To-Do List

Validación y optimización de Render Props y Render Functions en React

Uso de React.Children y React.CloneElement para Composición Avanzada

High Order Components