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
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éthode | Approche | Scénario d'application |
|---|---|---|
| Fonction gestionnaire d'événement | Filtrer directement dans onChange | Logique simple, déclenchée à un seul endroit |
| Réponse useEffect | useEffect dépend de keyword | Plusieurs 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
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
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
.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