Nuevos hooks que vendrán en React 19
A diferencia de lo que se cree comúnmente, el equipo central de React no se enfoca únicamente en React Server Components y Next.js. Nuevos hooks del lado del cliente están llegando en la próxima versión de React, React 19. Se centran en dos puntos principales: la obtención de datos y los formularios. Estos hooks mejorarán la productividad de todos los desarrolladores de React, incluidos aquellos que trabajan en SPA (single-page-application).
Los hooks que veremos en este artículo:
Nota: Estos hooks solo están disponibles en la versión Canary de React las cuales son experimentales. Deberían formar parte de la próxima versión React 19, pero la API puede cambiar antes del lanzamiento final.
use(Promise)
Este nuevo hook sirve para hacer un "suspense" en el cliente. Se le pasa una promesa y React podrá hacer un "suspense" hasta que se resuelva. La sintaxis básica, tomada de la documentación de uso de React, es:
import { use } from 'react';
function MessageComponent({ messagePromise }) {
const message = use(messagePromise);
// ...
}Este hook puede utilizarse para obtener datos. Aquí tienes un ejemplo de obtención de datos al cargar y al hacer clic en un botón. El código no utiliza ningún useEffect:
En el siguiente ejemplo, usamos faker-js (
npm i @faker-js/faker) para simular la obtención de datos, se utiliza el hookusepara suspender la carga hasta que la promesa se resuelva.
- El hook
usese utiliza en el componenteItems(1) para suspender la carga hasta que la promesa se resuelva. - El componente
Itemsse utiliza en el componenteItemsContainer(2) que se envuelve en un componenteSuspensepara suspender la carga de datos hasta que la promesa se resuelva. - Cada vez que se presiona el botón "Actualizar", se agrega un item nuevo al principio del array de
items.
import { useState, use, Suspense } from 'react';
import { faker } from '@faker-js/faker';
export const App = () => {
const [data, setData] = useState(() => fetchData());
const handleUpdate = () => {
fetchData().then((data) => {
setData(Promise.resolve(data));
});
};
return (
<>
<h3>
Nuevos items <button onClick={handleUpdate}>Actualizar</button>
</h3>
{/* (2) */}
<ItemsContainer data={data} />
</>
);
};
// creamos un array de 4 elementos
let items = [...new Array(4)].map(() => faker.lorem.sentence());
// simulamos una función que obtiene los datos
const fetchData = () =>
new Promise<string[]>((resolve) =>
// simulamos un data fetching con un setTimeout
setTimeout(() => {
// añadimos un item nuevo al principio
items.unshift(faker.lorem.sentence());
resolve(items);
}, 1000)
);
// (1)
const Items = ({ data }) => {
const items = use<string[]>(data);
return (
<ul>
{items.map((title, index) => (
<li key={index}>{title}</li>
))}
</ul>
);
};
// (2)
const ItemsContainer = ({ data }) => (
<Suspense fallback={<p>Solicitando items...</p>}>
<Items data={data} />
</Suspense>
);
Antes, la obtención de datos habilitada para "Suspense" sin el uso de un framework no era compatible.
Bueno, con React 19 ya será posible.
Este nuevo hook use, a diferencia de los demás React Hooks, puede ser llamado dentro de bucles y declaraciones condicionales como if.
use(Context)
El mismo hook use se puede usar para leer un Contexto de React. Es exactamente como useContext, excepto que se puede llamar dentro de bucles y declaraciones condicionales como if.
import { use } from 'react';
function HorizontalRule({ show }) {
if (show) {
const theme = use(ThemeContext);
return <hr className={theme} />;
}
return false;
}Esto simplificará la jerarquía de componentes para algunos casos de uso, ya que la única forma de leer un contexto en un bucle o una condición era dividir el componente en dos.
También es una gran evolución en términos de rendimiento, ya que ahora puedes omitir condicionalmente la renderización de un componente, aunque el contexto haya cambiado.
Ver DocumentaciónForm Actions
Esta nueva característica te permite pasar una función a la propiedad action de un elemento <form>. React llamará a esta función cuando se envíe el formulario:
<form action={handleSubmit} />Si agregamos la propiedad action (
<form action>) en React 18, obtenemos esta advertencia:
Warning: Invalid value for prop action on
<form>tag. Either remove it from the element or pass a string or number value to keep it in the DOM.
(Advertencia: Valor no válido para la propiedad action en la etiqueta
<form>. Elimínelo del elemento o pase un valor de cadena o número para mantenerlo en el DOM.)
Eso ya no va a suceder en React 19.
Ejemplo de uso de Form Actions para un formulario básico de carrito de compras
import { useState } from 'react';
// 1. Lista de productos
const productsList = [
{
id: '1',
title: 'Celurar Samsung Galaxy S21',
},
{
id: '2',
title: 'Laptop Dell XPS 13',
},
{
id: '3',
title: 'Tablet Samsung Galaxy Tab S7',
},
];
export const App = () => {
// 2. Estado del carrito
const [cart, setCart] = useState<Item[]>([]);
// 3. Agregar item al carrito
const addToCart = async (formData: FormData, title: string) => {
const id = String(formData.get('itemID'));
let qty = 1;
// Simulamos un envío de formulario con un setTimeout
await new Promise((resolve) => setTimeout(resolve, 1000));
const isInCart = cart.some((item) => item.id === id);
if (isInCart) {
// Si el item ya está en el carrito, aumentamos la cantidad
qty = cart.find((item) => item.id === id)!.qty + 1;
setCart((cart: Item[]) =>
cart.map((item) => (item.id === id ? { ...item, qty } : item))
);
} else {
// Si el item no está en el carrito, lo agregamos
setCart((cart: Item[]) => [...cart, { id, title, qty }]);
}
return { id };
};
// 4. Eliminar item del carrito
const removeFromCart = (id: string) => {
setCart((cart: Item[]) => cart.filter((item) => item.id !== id));
};
return (
<>
<Cart cart={cart} removeFromCart={removeFromCart} />
{productsList.map((item) => (
<AddToCartForm
key={item.id}
id={item.id}
title={item.title}
addToCart={addToCart}
/>
))}
</>
);
};
const AddToCartForm = ({ id, title, addToCart }) => {
// 5. Enviar formulario
const formAction = async (formData) => {
try {
await addToCart(formData, title);
} catch (e) {
// mostrar error
}
};
// 6. Renderizar formulario y usar formAction el cual cambia el estado del carrito con la función addToCart
return (
<form action={formAction}>
<h2>{title}</h2>
<input type="hidden" name="itemID" value={id} />
<button type="submit">Agregar al carrito</button>
</form>
);
};
type Item = {
id: string;
title: string;
qty: number;
};
type CartProps = {
cart: Item[];
removeFromCart: (id: string) => void;
};
const Cart = ({ cart, removeFromCart }: CartProps) => {
// 7. Renderizar el carrito y usar removeFromCart para eliminar un item del carrito
if (cart.length == 0) {
return null;
}
return (
<>
Tu carrito:
<ul>
{cart.map((item, index) => (
<li key={index}>
{item.title}
{item.qty > 1 ? ` (x${item.qty})` : ''}
<RemoveItemFromCart id={item.id} removeFromCart={removeFromCart} />
</li>
))}
</ul>
<hr />
</>
);
};
const RemoveItemFromCart = ({ id, removeFromCart }) => {
// 8. Renderizar botón para eliminar un item del carrito y usar removeFromCart para eliminar un item del carrito
const handleClick = () => {
removeFromCart(id);
};
return <button onClick={handleClick}>Eliminar del carrito</button>;
};La función addToCart no es una Acción de Servidor. Se llama en el lado del cliente y puede ser una función asíncrona.
Esto simplificará enormemente el manejo de formularios en React, como por ejemplo para un formulario de búsqueda. Pero nuevamente, esto puede no ser suficiente para deshacerse de bibliotecas de terceros como React Hook Form, que hace mucho más que simplemente manejar el envío del formulario (validación, efectos secundarios, etc).
Ver documentaciónPodés encontrar algunos problemas de usabilidad en el ejemplo anterior (botón de envío no deshabilitado mientras se envía, mensaje de confirmación faltante, actualización tardía del carrito). Por suerte, están llegando más hooks para ayudar con este caso de uso.
useFormState
Este nuevo hook tiene como objetivo ayudar con la característica de acción de formulario asíncrona explicada anteriormente. el hook useFormState te permite acceder al valor de retorno de una acción desde la última vez que se envió un formulario.
import { useFormState } from 'react-dom';
import { action } from './action';
function MyComponent() {
const [state, formAction] = useFormState(action, null);
// ...
return <form action={formAction}>{/* ... */}</form>;
}Este hook useFormState recive 2 argumentos obligatorios (action e initialState) y 1 opcional (permalink):
action: es la función que se llamará cuando se envíe el formulario.initialState: es el estado inicial que se pasará a la funciónactionla primera vez que se llame. Puede sernull.permalink: es una cadena opcional que se utilizará para almacenar el estado del formulario en la URL.
El hook useFormState retorna un array con dos elementos: el estado actual del formulario y la función para enviar el formulario:
state: es el estado actual del formulario.dispatch: es la función que se llamará para enviar el formulario.
El siguiente ejemplo es un contador básico:
import { useFormState } from 'react-dom';
async function increment(previousState, formData) {
return previousState + 1;
}
export const App = () => {
const [state, formAction] = useFormState(increment, 0);
return (
<form>
{state}
<button formAction={formAction}>Increment</button>
</form>
);
};Siguiendo con el ejemplo anterior del carrito, vemos como con el useFormState nos permite mostrar un mensaje de confirmación o un mensaje de error retornado por la acción del formulario:
// ...
// 1. Importamos useFormState =====
import { useFormState } from 'react-dom';
// =====
const productsList = [
//...
];
export const App = () => {
// ...
const addToCart = async (formData: FormData, title: string) => {
const id = String(formData.get('itemID'));
await new Promise((resolve) => setTimeout(resolve, 1000));
// 4. Simulamos que el producto de id 3 no tiene stock
if (id === '3') {
throw new Error('Sin stock');
}
const isInCart = cart.some((item) => item.id === id);
if (isInCart) return;
setCart((cart: Item[]) => [...cart, { id, title, qty: 1 }]);
return { id };
};
// ...
};
const AddToCartForm = ({ id, title, addToCart }) => {
// 3. Modificamos la función formAction y usamos el useFormState =====
const addToCartAction = async (prevState, formData) => {
try {
await addToCart(formData, title);
return 'Agregado al carrito';
} catch (e) {
return e.message.toString();
}
};
const [message, formAction] = useFormState(addToCartAction, null);
// =====
return (
<form action={formAction}>
<h2>{title}</h2>
<input type="hidden" name="itemID" value={id} />
<button type="submit">Agregar al carrito</button>
{/* 4. Agregamos el mensaje retornado de addToCartAction (puede ser un Toast, etc.) ===== */}
{message}
{/* ===== */}
</form>
);
};
//...Ver documentaciónNota:
useFormStatedebe ser importado desde react-dom, no desde react.
useFormStatus
useFormStatus te permite saber si un elemento <form> padre se está enviando actualmente o si se ha enviado correctamente. Puede ser llamado desde hijos del formulario, y devuelve un objeto con las siguientes propiedades:
const { pending, data, method, action } = useFormStatus();Se puede usar la propiedad data para mostrar qué datos está enviando el usuario. También puedes mostrar un estado pendiente en un botón mientras el formulario se está enviando.
Siguiendo con el ejemplo del carrito, crearemos un componente SubmitButton en el cuál implementaremos el useFormStatus, luego debemos modificar la función addToCartAction dentro del el componente AddToCartForm cambiando el <button> por <SubmitButton> para realizar el submit del formulario:
// ...
const AddToCartForm = ({ id, title, addToCart }) => {
const addToCartAction = async (prevState, formData) => {
try {
await addToCart(formData, title);
return 'Agregado al carrito';
} catch (e) {
return e.message.toString();
}
};
const [message, formAction] = useFormState(addToCartAction, null);
return (
<form action={formAction}>
<h2>{title}</h2>
<input type="hidden" name="itemID" value={id} />
{/* cambiamos <button> por <SubmitButton /> */}
<SubmitButton />
</form>
);
};
const SubmitButton = () => {
const { pending } = useFormStatus();
return (
<button disabled={pending} type="submit">
Agregar al carrito
</button>
);
};
// ...Nota:
useFormStatusdebe ser importado desde react-dom, no desde react. Además, solo funciona cuando el formulario padre utiliza la propiedadactionexplicado anteriormente.
Junto con useFormState, este hook mejorará la experiencia del usuario de los formularios del lado del cliente sin llenar tus componentes con un contexto o efectos inútiles.
useOptimistic
useOptimistic es un hook que te permite optimizar la experiencia del usuario al enviar formularios. Se puede mostrar un estado "optimista" mientras el formulario se está enviando, y revertirlo si el envío falla.
Este hook recibe 2 argumentos obligatorios (state y updateFn):
state: es el estado actual del formulario.updateFn: es la función que se llamará para actualizar el estado del formulario.
El hook useOptimistic retorna un array con dos elementos:
state: es el estado actual del formulario.dispatch: es la función que se llamará para enviar el formulario.
import { useOptimistic } from 'react';
function AppContainer() {
const [optimisticState, addOptimistic] = useOptimistic(
state,
// función actualizar estado
(currentState, optimisticValue) => {
// optimisticValue es el valor que se mostrará mientras el formulario se está enviando
}
);
}En el ejemplo del carrito anterior, podríamos usar este hook para mostrar el carrito con el nuevo item agregado antes de que la petición se haya completado:
- Importamos
useOptimisticde react. - Implementamos
useOptimisticenviando el estadocarty la función(state, item) => [...state, item]para agregar un item al carrito. - Enviamos el estado
optimisticCarten vez de cart - Enviamos la función
optimisticAddToCart - Enviamos al hook el id y el título del item que se está agregando si falla, retorna el estado anterior.
// 1. Importamos useOptimistic
import { useOptimistic, useState } from 'react';
import { useFormState, useFormStatus } from 'react-dom';
const productsList = [
{
id: '1',
title: 'Celurar Samsung Galaxy S21',
},
{
id: '2',
title: 'Laptop Dell XPS 13',
},
{
id: '3',
title: 'Tablet Samsung Galaxy Tab S7',
},
];
export const App = () => {
const [cart, setCart] = useState<Item[]>([]);
// 2. Implementamos el hook
const [optimisticCart, optimisticAddToCart] = useOptimistic<Item[], Item>(
cart,
(state, item) => [...state, item]
);
const addToCart = async (formData: FormData, title: string) => {
const id = String(formData.get('itemID'));
await new Promise((resolve) => setTimeout(resolve, 1000));
if (id === '3') {
throw new Error('Sin stock');
}
const isInCart = cart.some((item) => item.id === id);
if (isInCart) return;
setCart((cart: Item[]) => [...cart, { id, title, qty: 1 }]);
return { id };
};
const removeFromCart = (id: string) => {
setCart((cart: Item[]) => cart.filter((item) => item.id !== id));
};
return (
<>
{/* 3. Enviamos el estado optimisticCart en vez de cart */}
<Cart cart={optimisticCart} removeFromCart={removeFromCart} />
{productsList.map((item) => (
<AddToCartForm
key={item.id}
id={item.id}
title={item.title}
addToCart={addToCart}
// 4. Enviamos la función optimisticAddToCart
optimisticAddToCart={optimisticAddToCart}
/>
))}
</>
);
};
const AddToCartForm = ({ id, title, addToCart, optimisticAddToCart }) => {
const addToCartAction = async (prevState, formData) => {
// 5. Enviamos al hook el id y el título del item que se está agregando
// si falla, retorna el estado anterior
optimisticAddToCart({ id, title });
try {
await addToCart(formData, title);
return 'Agregado al carrito';
} catch (e) {
return e.message.toString();
}
};
const [message, formAction] = useFormState(addToCartAction, null);
return (
<form action={formAction}>
<h2>{title}</h2>
<input type="hidden" name="itemID" value={id} />
<SubmitButton />
</form>
);
};
const SubmitButton = () => {
const { pending } = useFormStatus();
return (
<button disabled={pending} type="submit">
Agregar al carrito
</button>
);
};
type Item = {
id: string;
title: string;
qty: number;
};
type CartProps = {
cart: Item[];
removeFromCart: (id: string) => void;
};
const Cart = ({ cart, removeFromCart }: CartProps) => {
if (cart.length == 0) {
return null;
}
return (
<>
Tu carrito:
<ul>
{cart.map((item, index) => (
<li key={index}>
{item.title}
{item.qty > 1 ? ` (x${item.qty})` : ''}
<RemoveItemFromCart id={item.id} removeFromCart={removeFromCart} />
</li>
))}
</ul>
<hr />
</>
);
};
const RemoveItemFromCart = ({ id, removeFromCart }) => {
const handleClick = () => {
removeFromCart(id);
};
return <button onClick={handleClick}>Eliminar del carrito</button>;
};Optimizar la actualización de la UI es una gran manera de mejorar la experiencia del usuario de una aplicación web. Este hook ayuda mucho con este caso de uso.
Ver documentaciónuseTransition
El useTransición te permite actualizar el estado sin bloquear la interfaz de usuario. Por ejemplo, permite cancelar un cambio de estado previo si el usuario cambia de opinión.
La idea es envolver un cambio de estado con una llamada a startTransition.
function TabContainer() {
const [isPending, startTransition] = useTransition();
const [tab, setTab] = useState('about');
function selectTab(nextTab) {
// en vez de setTab(nextTab), poner el cambio de estado en una transición
startTransition(() => {
setTab(nextTab);
});
}
// ...
}El siguiente ejemplo muestra una navegación de pestañas utilizando esta API de Transiciones. Si se hace clic en "Posts" y luego inmediatamente se hace clic en "Contacto", se observa que esto interrumpe la renderización lenta de "Post" y la pestaña "Contacto" se muestra inmediatamente. Como esta actualización de estado está marcada como una transición, una renderización lenta no bloquea la interfaz de usuario:
- Primero creamos
AboutTab
export default function AboutTab() {
return <p>Sobre mi!</p>;
}- Luego creamos
PostsTab
import { memo } from 'react';
const PostsTab = memo(function PostsTab() {
// Imprime una vez. La ralentización real está dentro de SlowPost.
console.log('[LENTITUD GENERADA] Renderizando 500 <SlowPost />');
let items = [];
for (let i = 0; i < 500; i++) {
items.push(<SlowPost key={i} index={i} />);
}
return <ul className="items">{items}</ul>;
});
function SlowPost({ index }) {
let startTime = performance.now();
while (performance.now() - startTime < 1) {
// No hacer nada por 1 ms por item para emular un código extremadamente lento
}
return <li className="item">Post #{index + 1}</li>;
}
export default PostsTab;- Luego creamos
ContactTab
export default function ContactTab() {
return (
<>
<p>Contactame:</p>
<ul>
<li>admin@email.com</li>
<li>+123456789</li>
</ul>
</>
);
}- Luego creamos el
TabButton
export default function TabButton({ children, isActive, onClick }) {
if (isActive) {
return <b>{children}</b>;
}
return (
<button
onClick={() => {
onClick();
}}
>
{children}
</button>
);
}- Definimos los estilos de la aplicación
* {
box-sizing: border-box;
}
body {
font-family: sans-serif;
margin: 20px;
padding: 0;
}
h1 {
margin-top: 0;
font-size: 22px;
}
h2 {
margin-top: 0;
font-size: 20px;
}
h3 {
margin-top: 0;
font-size: 18px;
}
h4 {
margin-top: 0;
font-size: 16px;
}
h5 {
margin-top: 0;
font-size: 14px;
}
h6 {
margin-top: 0;
font-size: 12px;
}
code {
font-size: 1.2em;
}
ul {
padding-inline-start: 20px;
}
button {
margin-right: 10px;
}
b {
display: inline-block;
margin-right: 10px;
}- Finalmente trabajamos en el componente
App
import { useState, useTransition } from 'react';
import TabButton from './TabButton';
import AboutTab from './AboutTab';
import PostsTab from './PostsTab';
import ContactTab from './ContactTab';
export function App() {
const [isPending, startTransition] = useTransition();
const [tab, setTab] = useState('about');
function selectTab(nextTab) {
startTransition(() => {
setTab(nextTab);
});
}
return (
<>
<TabButton isActive={tab === 'about'} onClick={() => selectTab('about')}>
About
</TabButton>
<TabButton isActive={tab === 'posts'} onClick={() => selectTab('posts')}>
Posts (slow)
</TabButton>
<TabButton
isActive={tab === 'contact'}
onClick={() => selectTab('contact')}
>
Contact
</TabButton>
<hr />
{tab === 'about' && <AboutTab />}
{tab === 'posts' && <PostsTab />}
{tab === 'contact' && <ContactTab />}
</>
);
}El hook useTransition ya está disponible en React 18.2. Lo nuevo en React 19 es que ahora puedes pasar una función asíncrona a startTransition, que es esperada por React para iniciar la transición.
Esto es útil para enviar datos a través de una petición y renderizar el resultado en una transición. El estado pendiente de la transición comienza con el envío asíncrono de datos. Ya se usa en la función de acciones de formulario explicada anteriormente. Esto significa que React llama al controlador <form action> envuelto en startTransition, por lo que no bloquea la página actual.
Esta característica todavía no está documentada en React, pero puedes leer más al respecto en la solicitud de extracción.
Conclusión 👨🏫
Todas estas características funcionan en aplicaciones de React solo en el cliente, por ejemplo, en aplicaciones empaquetadas con Vite. No necesitas un framework de SSR como Next.js para usarlas, aunque también funcionan con aplicaciones de React integradas en el servidor.
Con estas características, la obtención de datos y los formularios se vuelven significativamente más fáciles de implementar en React. Sin embargo, crear una gran experiencia de usuario implica integrar todos estos hooks, lo que puede ser complejo.
No se sabe cuando se lanzará React 19, pero todas las características mencionadas en este artículo están funcionando. No se recomienda usarlas en producción todavía (aunque Next.js lo haga), ya que esto esta en fase experimental.
Gracias por leer. Nos vemos! 👋