useEffect avancé — Recherche en temps réel

Dans ce chapitre, vous allez plonger dans le mécanisme de changement de dépendances de useEffect pour implémenter un filtrage en temps réel et une optimisation par debounce pour la zone de recherche.


Déclencheur de changement de dépendance useEffect

Lorsqu'une valeur du tableau de dépendances useEffect change, React réexécutera l'effet.

Exemple

import { useState, useEffect } from 'react'

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

  // Chaque fois que keyword change, réexécutez le filtrage
  useEffect(() => {
    console.log('keyword changé en :', keyword)
    // Vous pouvez exécuter la logique de recherche ici
    setResults(/* Résultats filtrés */)
  }, [keyword])  // Dépend de keyword

  return (
    <div>
      <input
        value={keyword}
        onChange={e => setKeyword(e.target.value)}
        placeholder="Rechercher..."
      />
      <p>Recherche actuelle :{keyword}</p>
    </div>
  )
}

Ce modèle convient pour surveiller un état et exécuter automatiquement l'opération correspondante lorsqu'il change.


Gestion dans les événements vs useEffect

Il existe deux façons d'implémenter le filtrage de recherche :

MéthodeApprocheScénario d'application
Fonction gestionnaire d'événementFiltrer directement dans onChangeLogique simple, déclenchée à un seul endroit
Réponse useEffectuseEffect dépend de keywordPlusieurs sources de données peuvent affecter le résultat du filtre

Dans le scénario du blog, la logique de filtrage pour la saisie dans le champ de recherche est très simple,Il est plus approprié de la placer directement dans un gestionnaire d'événement ou useMemo.。

useEffect est plus adapté aux scénarios nécessitant une synchronisation avec des systèmes externes (comme l'appel d'API, l'enregistrement dans localStorage).


Optimisation du debounce

Si chaque frappe au clavier déclenche une recherche (le filtrage local convient, mais si cela implique l'envoi de requêtes réseau), cela entraînerait beaucoup de gaspillage.

Anti-rebondL'idée : une fois que l'utilisateur a arrêté de taper pendant un certain temps, exécuter l'opération.

Exemple

import { useState, useEffect } from 'react'

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

  useEffect(() => {
    // Définir un minuteur : mettre à jour debouncedValue après delay ms
    const timer = setTimeout(() => {
      setDebouncedValue(value)
    }, delay)

    // Fonction de nettoyage : si value change à nouveau pendant delay, effacer le minuteur précédent
    return () => clearTimeout(timer)
  }, [value, delay])

  return debouncedValue
}

// Utiliser l'anti-rebond
function SearchInput() {
  const [keyword, setKeyword] = useState('')
  const debouncedKeyword = useDebounce(keyword, 300)

  // Exécuter uniquement lorsque la valeur debouncée change (par ex., envoyer une requête)
  useEffect(() => {
    if (debouncedKeyword) {
      console.log('Exécution effective de la recherche :', debouncedKeyword)
      // fetch(`/api/search?q=${debouncedKeyword}`)
    }
  }, [debouncedKeyword])

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

Le principe du debounce : chaque saisie réinitialise un minuteur de 300ms. Ce n'est que lorsqu'aucune nouvelle saisie n'a lieu dans les 300ms que le minuteur s'exécute et que debouncedKeyword est mis à jour. Ainsi, la recherche ne sera pas déclenchée fréquemment lorsque l'utilisateur tape rapidement.


Mise en pratique : Ajouter une recherche en temps réel au blog

Exemple

// Chemin du fichier : 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('Toutes')
  const [keyword, setKeyword] = useState('')   // Mot-clé de recherche

  // Charger les données
  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 ['Toutes', ...new Set(articles.map(a => a.category))]
  }, [articles])

  // Filtrer + rechercher : filtrer à la fois par catégorie et par mot-clé
  const filteredArticles = useMemo(() => {
    let result = articles

    // D'abord filtrer par catégorie
    if (activeCategory !== 'All') {
      result = result.filter(a => a.category === activeCategory)
    }

    // Ensuite filtrer par mot-clé
    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">Derniers articles</h2>

      {/* Champ de recherche */}
      <div className="search-bar">
        <input
          type="text"
          value={keyword}
          onChange={e => setKeyword(e.target.value)}
          placeholder="Rechercher dans les titres ou résumés d'articles..."
          className="search-input"
        />
        {keyword && (
          <span className="clear-btn" onClick={() => setKeyword('')}>✕</span>
        )}
      </div>

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

      {error && (
        <div className="status-msg error">
          <p>Échec du chargement :{error}</p>
          <button onClick={() => window.location.reload()}>Réessayer</button>
        </div>
      )}

      {!isLoading && !error && (
        <>
          <CategoryFilter
            categories={categories}
            activeCategory={activeCategory}
            onCategoryChange={setActiveCategory}
          />
          <p className="result-info">
common{filteredArticles.length}article
            {keyword &&`, recherche de "${keyword}」`}
          </p>
          {filteredArticles.length === 0 ? (
            <p className="empty-tip">Aucun article correspondant trouvé</p>
          ) : (
            <div className="article-grid">
              {filteredArticles.map(article => (
                <BlogCard key={article.id} {...article} />
              ))}
            </div>
          )}
        </>
      )}
    </div>
  )
}

export default HomePage

Exemple

/* Styles de la zone de recherche (à ajouter à 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 recherche et le filtrage par catégorie peuvent fonctionner simultanément — après avoir saisi un mot-clé, cliquer sur un bouton de catégorie applique les deux conditions pour filtrer.


Résumé du chapitre

Dans ce chapitre, vous avez approfondi le mécanisme de changement de dépendances de useEffect : l'effet se réexécute lorsque les valeurs du tableau de dépendances changent, le principe et la mise en œuvre du debounce (setTimeout + nettoyage), et la frontière de sélection entre useEffect et les gestionnaires d'événements.

L'expérience de filtrage en temps réel de la zone de recherche est fluide — c'est là tout l'intérêt de la programmation déclarative : vous déclarez la règle de calcul pour filteredArticles, et React la recalcule automatiquement lorsque ses dépendances changent.

Autres extensions