useEffect Avanzado — Búsqueda en tiempo real

En este capítulo profundizarás en el mecanismo de cambios de dependencias de useEffect, implementando filtrado en tiempo real y optimización con debounce en el cuadro de búsqueda.


useEffect: Disparo por cambios en dependencias

Cuando un valor en el array de dependencias de useEffect cambia, React vuelve a ejecutar el effect.

Ejemplo

import { useState, useEffect } from 'react'

function SearchDemo() {
  const [keyword, setKeyword] = useState('')
  const [results, setResults] = useState([])

  // Cada vez que keyword cambia, vuelve a ejecutar el filtrado
  useEffect(() => {
    console.log('keyword cambió a:', keyword)
    // Aquí puedes ejecutar la lógica de búsqueda
    setResults(/* Filtrar resultados */)
  }, [keyword])  // Depende de keyword

  return (
    <div>
      <input
        value={keyword}
        onChange={e => setKeyword(e.target.value)}
        placeholder="Buscando..."
      />
      <p>Búsqueda actual:{keyword}</p>
    </div>
  )
}

Este patrón es adecuado para escuchar un state y ejecutar automáticamente la operación correspondiente cuando cambia.


Manejar en eventos vs useEffect

El filtrado de búsqueda tiene dos formas de implementación:

MétodoSintaxisCasos de uso
Funciones manejadoras de eventosFiltrar directamente en onChangeLógica simple, se activa en un solo lugar
Respuesta con useEffectuseEffect depende de keywordMúltiples fuentes de datos pueden afectar el resultado del filtrado

En el escenario del blog, la lógica de filtrado de la entrada del cuadro de búsqueda es muy simple,es más adecuado colocarla directamente en una función manejadora de eventos o en useMemo。

useEffect es más adecuado para escenarios que necesitan sincronizarse con sistemas externos (como llamar a APIs o guardar en localStorage).


Optimización con debounce

Si cada pulsación de tecla dispara la búsqueda (el filtrado local no es problema, pero si se envía una solicitud de red), se produce un gran desperdicio.

DebounceLa idea: ejecutar la operación después de que el usuario deje de escribir durante un tiempo.

Ejemplo

import { useState, useEffect } from 'react'

function useDebounce(value, delay = 300) {
  const [debouncedValue, setDebouncedValue] = useState(value)

  useEffect(() => {
    // Configurar el temporizador: actualizar debouncedValue después de delay ms
    const timer = setTimeout(() => {
      setDebouncedValue(value)
    }, delay)

    // Función de limpieza: si value cambia dentro de delay, limpiar el temporizador anterior
    return () => clearTimeout(timer)
  }, [value, delay])

  return debouncedValue
}

// Usar debounce
function SearchInput() {
  const [keyword, setKeyword] = useState('')
  const debouncedKeyword = useDebounce(keyword, 300)

  // Ejecutar solo cuando el valor con debounce cambia (por ejemplo, enviar una solicitud)
  useEffect(() => {
    if (debouncedKeyword) {
      console.log('Ejecutando la búsqueda real:', debouncedKeyword)
      // fetch(`/api/search?q=${debouncedKeyword}`)
    }
  }, [debouncedKeyword])

  return (
    <input
      value={keyword}
      onChange={e => setKeyword(e.target.value)}
      placeholder="Buscando..."
    />
  )
}

El principio del debounce: cada entrada reinicia un temporizador de 300ms. Solo cuando no hay nuevas entradas dentro de 300ms, el temporizador se ejecuta y debouncedKeyword se actualiza. Así, cuando el usuario escribe rápidamente, la búsqueda no se dispara con frecuencia.


Manos a la obra: Añadir búsqueda en tiempo real al blog

Ejemplo

// Ruta del archivo: src/pages/HomePage.jsx
import { useState, useEffect, useMemo } from 'react'
import BlogCard from '../components/BlogCard'
import CategoryFilter from '../components/CategoryFilter'

function HomePage() {
  const [articles, setArticles] = useState([])
  const [isLoading, setIsLoading] = useState(true)
  const [error, setError] = useState(null)
  const [activeCategory, setActiveCategory] = useState('Todos')
  const [keyword, setKeyword] = useState('')   // Palabra clave de búsqueda

  // Cargar datos
  useEffect(() => {
    let cancelled = false
    async function fetchPosts() {
      setIsLoading(true)
      try {
        const res = await fetch('/posts.json')
        const data = await res.json()
        if (!cancelled) setArticles(data)
      } catch (err) {
        if (!cancelled) setError(err.message)
      } finally {
        if (!cancelled) setIsLoading(false)
      }
    }
    fetchPosts()
    return () => { cancelled = true }
  }, [])

  const categories = useMemo(() => {
    return ['Todos', ...new Set(articles.map(a => a.category))]
  }, [articles])

  // Filtrar + buscar: filtrar por categoría y palabra clave al mismo tiempo
  const filteredArticles = useMemo(() => {
    let result = articles

    // Primero filtrar por categoría
    if (activeCategory !== 'Todos') {
      result = result.filter(a => a.category === activeCategory)
    }

    // Luego filtrar por palabra clave
    if (keyword.trim()) {
      const kw = keyword.trim().toLowerCase()
      result = result.filter(a =>
        a.title.toLowerCase().includes(kw) ||
        a.summary.toLowerCase().includes(kw)
      )
    }

    return result
  }, [articles, activeCategory, keyword])

  return (
    <div>
      <h2 className="section-title">Artículos recientes</h2>

      {/* Cuadro de búsqueda */}
      <div className="search-bar">
        <input
          type="text"
          value={keyword}
          onChange={e => setKeyword(e.target.value)}
          placeholder="Buscar título o resumen del artículo..."
          className="search-input"
        />
        {keyword && (
          <span className="clear-btn" onClick={() => setKeyword('')}>✕</span>
        )}
      </div>

      {isLoading && <p className="status-msg">Cargando...</p>}

      {error && (
        <div className="status-msg error">
          <p>Error al cargar:{error}</p>
          <button onClick={() => window.location.reload()}>Reintentar</button>
        </div>
      )}

      {!isLoading && !error && (
        <>
          <CategoryFilter
            categories={categories}
            activeCategory={activeCategory}
            onCategoryChange={setActiveCategory}
          />
          <p className="result-info">
común{filteredArticles.length}artículo
            {keyword &&`, buscando «${keyword}」`}
          </p>
          {filteredArticles.length === 0 ? (
            <p className="empty-tip">No se encontraron artículos que coincidan</p>
          ) : (
            <div className="article-grid">
              {filteredArticles.map(article => (
                <BlogCard key={article.id} {...article} />
              ))}
            </div>
          )}
        </>
      )}
    </div>
  )
}

export default HomePage

Ejemplo

/* Estilos del cuadro de búsqueda (agregar a App.css) */
.search-bar {
  position: relative;
  margin-bottom: 20px;
}

.search-input {
  width: 100%;
  padding: 12px 40px 12px 16px;
  border: 2px solid #eee;
  border-radius: 8px;
  font-size: 15px;
  outline: none;
  transition: border-color 0.2s;
}

.search-input:focus {
  border-color: #1976d2;
}

.clear-btn {
  position: absolute;
  right: 12px;
  top: 50%;
  transform: translateY(-50%);
  cursor: pointer;
  color: #999;
  font-size: 18px;
}

.status-msg {
  text-align: center;
  padding: 60px 0;
  font-size: 16px;
  color: #999;
}

.status-msg.error {
  color: #e74c3c;
}

.status-msg.error button {
  margin-left: 10px;
  padding: 4px 12px;
  cursor: pointer;
}

La búsqueda y el filtrado por categoría pueden funcionar simultáneamente: después de ingresar la palabra clave, al hacer clic en el botón de categoría, ambas condiciones se combinan para filtrar.


Resumen del capítulo

En este capítulo profundizaste en el mecanismo de cambios de dependencias de useEffect: el effect se vuelve a ejecutar cuando cambia un valor en el array de dependencias, el principio y la implementación del debounce (setTimeout + cleanup), y los límites de elección entre useEffect y las funciones manejadoras de eventos.

La experiencia de filtrado en tiempo real del cuadro de búsqueda es fluida: este es el valor de la programación declarativa. Declaras las reglas de cálculo de filteredArticles y React automáticamente recalcula cuando sus dependencias cambian.

Otras extensiones