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:

jsx
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 hook use para suspender la carga hasta que la promesa se resuelva.

  1. El hook use se utiliza en el componente Items (1) para suspender la carga hasta que la promesa se resuelva.
  2. El componente Items se utiliza en el componente ItemsContainer (2) que se envuelve en un componente Suspense para suspender la carga de datos hasta que la promesa se resuelva.
  3. Cada vez que se presiona el botón "Actualizar", se agrega un item nuevo al principio del array de items.
jsx
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.

Ver Documentación

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.

jsx
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ón

Form 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:

jsx
<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
jsx
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).

Podé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.

Ver documentación

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.

jsx
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):

  1. action: es la función que se llamará cuando se envíe el formulario.
  2. initialState: es el estado inicial que se pasará a la función action la primera vez que se llame. Puede ser null.
  3. 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:

  1. state: es el estado actual del formulario.
  2. dispatch: es la función que se llamará para enviar el formulario.

El siguiente ejemplo es un contador básico:

jsx
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:

jsx
// ...
 
// 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>
  );
};
 
//...

Nota: useFormState debe ser importado desde react-dom, no desde react.

Ver documentación

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:

jsx
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:

jsx
// ...
 
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: useFormStatus debe ser importado desde react-dom, no desde react. Además, solo funciona cuando el formulario padre utiliza la propiedad action explicado 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.

Ver documentación

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):

  1. state: es el estado actual del formulario.
  2. updateFn: es la función que se llamará para actualizar el estado del formulario.

El hook useOptimistic retorna un array con dos elementos:

  1. state: es el estado actual del formulario.
  2. dispatch: es la función que se llamará para enviar el formulario.
jsx
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:

  1. Importamos useOptimistic de react.
  2. Implementamos useOptimistic enviando el estado cart y la función (state, item) => [...state, item] para agregar un item al carrito.
  3. Enviamos el estado optimisticCart en vez de cart
  4. Enviamos la función optimisticAddToCart
  5. Enviamos al hook el id y el título del item que se está agregando si falla, retorna el estado anterior.
jsx
// 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ón

useTransition

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.

jsx
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:

  1. Primero creamos AboutTab
jsx
export default function AboutTab() {
  return <p>Sobre mi!</p>;
}
  1. Luego creamos PostsTab
jsx
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;
  1. Luego creamos ContactTab
jsx
export default function ContactTab() {
  return (
    <>
      <p>Contactame:</p>
      <ul>
        <li>admin@email.com</li>
        <li>+123456789</li>
      </ul>
    </>
  );
}
  1. Luego creamos el TabButton
jsx
export default function TabButton({ children, isActive, onClick }) {
  if (isActive) {
    return <b>{children}</b>;
  }
  return (
    <button
      onClick={() => {
        onClick();
      }}
    >
      {children}
    </button>
  );
}
  1. Definimos los estilos de la aplicación
css
* {
  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;
}
  1. Finalmente trabajamos en el componente App
jsx
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! 👋