0Pricing
React Academy · Lección

useDeferredValue para aplicar debounce a entradas

Retrase los renderizados de las partes lentas de la UI mientras mantiene una respuesta ágil en las entradas.

useDeferredValue para aplicar debounce a entradas es una lección gratuita de React Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de React Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de React Academy incluye 4 lecciones en total.

Bienvenida

En esta lección usará useDeferredValue para retrasar el renderizado de las partes costosas de la interfaz y mantener las entradas controladas ágiles y receptivas.

¿Qué es useDeferredValue?

useDeferredValue acepta un valor y devuelve una versión retrasada de este. El valor retrasado queda por detrás del valor actual durante los renderizados urgentes, lo que permite que React actualice la interfaz en dos pasos: primero la entrada rápida y después la salida costosa.
const [query, setQuery] = useState('');
const deferredQuery = useDeferredValue(query);
// query updates immediately on keystroke
// deferredQuery updates when React has capacity

Aplicación a componentes costosos

Pase el valor retrasado (no el valor actual) al componente costoso. El componente costoso solo vuelve a renderizarse cuando cambia deferredQuery, que queda por detrás de la entrada al escribir rápidamente.
function App() {
  const [q, setQ] = useState('');
  const dq = useDeferredValue(q);
  return (
    <>
      <input value={q} onChange={e => setQ(e.target.value)} />
      <HeavyList query={dq} /> {/* renders with deferred value */}
    </>
  );
}

Mostrar un indicador de contenido obsoleto

Compare el valor actual con el valor retrasado. Cuando son diferentes, el contenido está obsoleto y puede atenuarlo con opacity o mostrar un indicador de carga.
const isStale = q !== dq;
<div style={{ opacity: isStale ? 0.5 : 1 }}>
  <HeavyList query={dq} />
</div>

useDeferredValue frente a debounce

El debounce basado en setTimeout siempre introduce un retraso fijo (por ejemplo, de 300 ms), incluso en máquinas rápidas. useDeferredValue se adapta: en dispositivos rápidos renderiza de inmediato y en dispositivos lentos retrasa el renderizado para evitar tirones.

useDeferredValue frente a useTransition

Use useTransition cuando USTED controla el setter de estado (puede envolver setState). Use useDeferredValue cuando recibe un valor como prop o desde un contexto y no puede controlar cuándo se actualiza.
// You own the state: use useTransition
startTransition(() => setTab(newTab));

// You receive the value: use useDeferredValue
const deferredProp = useDeferredValue(props.searchQuery);

Combinación con React.memo

Para que useDeferredValue omita renderizados de forma eficaz, el componente costoso debe estar envuelto en React.memo. Sin ello, el componente se vuelve a renderizar cada vez que se renderiza de nuevo el componente padre, independientemente del valor retrasado.
const HeavyList = React.memo(function({ query }) {
  // expensive rendering
  return <ul>{data.filter(q => ...).map(...)}</ul>;
});

El valor retrasado en el renderizado inicial

En el renderizado inicial, el valor retrasado es igual al valor actual; no hay retraso. El aplazamiento solo comienza cuando los valores actual y retrasado son diferentes durante un nuevo renderizado.

Varios valores retrasados

Puede llamar a useDeferredValue varias veces para distintas partes costosas de la interfaz; cada una se retrasa de forma independiente.
const deferredA = useDeferredValue(valueA);
const deferredB = useDeferredValue(valueB);

Limitaciones

useDeferredValue no hace que el renderizado sea más rápido; simplemente lo retrasa. Si el renderizado costoso tarda 500 ms, la interfaz seguirá teniendo tirones. Combínelo con la virtualización (react-virtual) para listas realmente grandes.

Comprobación rápida

¿Cuándo ofrece useDeferredValue ventajas frente a un valor normal?

Resumen

useDeferredValue devuelve una versión retrasada de un valor. Pásela a componentes costosos envueltos en React.memo. Muestre un indicador de contenido obsoleto cuando deferredValue !== value. Prefiéralo al debounce con retraso fijo para obtener un rendimiento adaptable.

A continuación

Siguiente lección: **Suspense para límites de datos y código**: combinará Suspense con la carga diferida y bibliotecas de datos para crear estados de carga claros.

Preguntas frecuentes

¿La lección «useDeferredValue para aplicar debounce a entradas» es gratis?

Sí — el texto completo de «useDeferredValue para aplicar debounce a entradas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de React Academy, actualiza a CoddyKit PRO. El curso de React Academy incluye 4 lecciones en total.

¿Qué aprenderé en «useDeferredValue para aplicar debounce a entradas»?

Retrase los renderizados de las partes lentas de la UI mientras mantiene una respuesta ágil en las entradas. Practicas React Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar React Academy?

No se requiere experiencia previa. React Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «useDeferredValue para aplicar debounce a entradas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de React Academy?

Sí. Cada lección de React Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Condiciones de carrera y limpieza de efectos
  2. useTransition para actualizaciones de UI no bloqueantes
  3. useDeferredValue para aplicar debounce a entradas
  4. Suspense para límites de datos y código
← Volver a React Academy