Découpage des composants — Props et callbacks d'événements
La décomposition en composants est la philosophie de conception fondamentale de React. Dans ce chapitre, vous apprendrez à découper les pages en petits composants réutilisables et à mettre en œuvre la communication parent-enfant via les Props et les fonctions de rappel.
Pourquoi découper les composants ?
App.jsx devient de plus en plus long, avec des centaines de lignes entassées, ce qui le rend difficile à maintenir et à réutiliser.
Principes de découpage des composants :Chaque composant est responsable d'une seule chose, et ils se combinent pour accomplir des fonctionnalités complexes.。
Quelle granularité est appropriée ?
| Zone de page | Faut-il le découper en un composant ? | Raison |
|---|---|---|
| Barre de navigation | Oui | Chaque page en a besoin ; fonctionnalité indépendante |
| Carte d'article | Oui | Chaque article de la liste a la même structure |
| Groupe de boutons de filtrage par catégorie | Oui | Possède son propre état et ses propres interactions |
| Conteneur d'encapsulation simple | non | Uniquement pour la mise en page, aucun comportement indépendant |
Du parent à l'enfant : Props
Dans React,les props sont des paramètres de fonction— lorsque le composant parent appelle un composant enfant, il transmet les données via des attributs.
Exemple
// Les props constituent le premier paramètre de la fonction, généralement utilisées avec la déstructuration
function BlogCard({ title, summary, date, category }) {
return (
<div className="card">
<span className="tag">{catégorie}</span>
<h3>{title}</h3>
<p>{summary}</p>
<span className="date">{date}</span>
</div>
)
}
export default BlogCard
Le composant parent transmet les données comme on écrirait des attributs HTML :
Exemple
import BlogCard from './components/BlogCard'
function App() {
const articles = [
{ id: 1, title: 'Introduction à React', summary: 'Apprendre React de zéro', date: '2024-05-10', category: 'React' },
{ id: 2, title: 'Les promesses en détail', summary: 'Comprendre l'asynchrone', date: '2024-05-08', category: 'JavaScript' },
]
return (
<div className="article-grid">
{articles.map(article => (
<BlogCard
key={article.id}
title={article.title}
summary={article.summary}
date={article.date}
category={article.category}
/>
))}
</div>
)
}
Les Props sontun flux de données unidirectionnel: les données circulent du composant parent vers le composant enfant. Un composant enfant ne peut pas modifier les Props qu’il reçoit. Si une modification est nécessaire, le composant parent doit la gérer au moyen d’une fonction de rappel.
Enfant vers parent : fonction de rappel
Lorsqu’un composant enfant doit notifier le composant parent que « quelque chose s’est produit », le composant parent doit passer unefonction de rappelen tant que Props.
Exemple
function CategoryFilter({ categories, activeCategory, onCategoryChange }) {
return (
<div className="filter-bar">
{categories.map(cat => (
<button
key={cat}
className={activeCategory === cat ? 'active' : ''}
// Appeler la fonction de rappel transmise par le composant parent lors du clic
onClick={() => onCategoryChange(cat)}
>
{cat}
</button>
))}
</div>
)
}
export default CategoryFilter
Le composant parent transmet la fonction de rappel :
Exemple
import CategoryFilter from './components/CategoryFilter'
function App() {
const [activeCategory, setActiveCategory] = useState('Toutes')
const categories = ['All', 'React', 'JavaScript', 'CSS']
// Fonction de rappel : répondre à l'événement de clic du composant enfant
function handleCategoryChange(cat) {
setActiveCategory(cat)
}
return (
<CategoryFilter
categories={categories}
activeCategory={activeCategory}
onCategoryChange={handleCategoryChange}
/>
)
}
Comparaison de la communication entre React et Vue3
| Scénario | Vue3 | React |
|---|---|---|
| Du parent à l'enfant | Props(defineProps) | Props (paramètres de fonction) |
| De l'enfant au parent | Émettre un événement | Fonction de rappel via props |
| Direction des données | Unidirectionnel | Unidirectionnel |
Vue3 utilise le mécanisme emit, React utilise des fonctions de rappel — l'essence est la même, seule la syntaxe diffère.
Déstructuration des props et valeurs par défaut
Exemple
function BlogCard({
title = 'Article sans titre', // valeurs par défaut de déstructuration ES6
summary = 'Pas encore de résumé',
date = '',
category = 'Sans catégorie'
}) {
return (
<div className="card">
<span className="tag">{catégorie}</span>
<h3>{title}</h3>
<p>{summary}</p>
{date && <span className="date">{date}</span>}
</div>
)
}
Mise en pratique : extraire trois composants
La structure des composants du projet de blog est la suivante :
src/ ├── components/ │ ├── NavBar.jsx # 顶部导航栏 │ ├── BlogCard.jsx # 单篇文章卡片 │ └── CategoryFilter.jsx # 分类筛选按钮组 └── App.jsx
NavBar.jsx
Exemple
import '../App.css'
function NavBar() {
return (
<header className="navbar">
<a href="/" className="logo">EXEMPLE Blog</a>
<nav>
<a href="/">Accueil</a>
<a href="#">À propos</a>
</nav>
</header>
)
}
export default NavBar
App.jsx — Intégration de tous les composants
Exemple
import { useState, useMemo } from 'react'
import NavBar from './components/NavBar'
import BlogCard from './components/BlogCard'
import CategoryFilter from './components/CategoryFilter'
import './App.css'
function App() {
const [articles] = useState([
{ id: 1, title: 'Le guide complet pour démarrer avec React', summary: 'Apprendre les Hooks React à partir de zéro', date: '2024-05-10', category: 'React' },
{ id: 2, title: 'Programmation asynchrone en JS en détail', summary: Comprendre Promise et async/await, date: '2024-05-08', category: 'JavaScript' },
{ id: 3, title: Mise en page pratique avec CSS Grid, summary: 'Implémenter une mise en page responsive avec Grid', date: '2024-05-05', category: 'CSS' },
{ id: 4, title: 'Plongée en profondeur dans les Hooks React', summary: 'Compréhension approfondie de useState et useEffect', date: '2024-05-03', category: 'React' },
{ id: 5, title: 'Le guide complet de Flexbox', summary: 'Apprendre la mise en page Flex en un seul article', date: '2024-05-01', category: 'CSS' },
])
const [activeCategory, setActiveCategory] = useState('Toutes')
const categories = useMemo(() => {
const cats = articles.map(a => a.category)
return ['Tous', ...new Set(cats)]
}, [articles])
const filteredArticles = useMemo(() => {
if (activeCategory === 'Tous') return articles
return articles.filter(a => a.category === activeCategory)
}, [articles, activeCategory])
return (
<div className="app">
<NavBar />
<main className="container">
<h2 className="section-title">Derniers articles</h2>
{/* Composant enfant : reçoit des props (categories, activeCategory) et un callback (onCategoryChange) */}
<CategoryFilter
categories={categories}
activeCategory={activeCategory}
onCategoryChange={setActiveCategory}
/>
<p className="result-info">common{filteredArticles.length}article</p>
{filteredArticles.length === 0 ? (
<p className="empty-tip">Aucun article dans cette catégorie pour le moment</p>
) : (
<div className="article-grid">
{filteredArticles.map(article => (
<BlogCard
key={article.id}
title={article.title}
summary={article.summary}
date={article.date}
category={article.category}
/>
))}
</div>
)}
</main>
<footer className="footer">
<p>© 2024 EXEMPLE Blog. Propulsé par React.</p>
</footer>
</div>
)
}
export default App
Résumé du chapitre
Dans ce chapitre, vous avez maîtrisé le cœur de la communication entre composants React : du parent à l'enfant via les Props (paramètres de fonction), de l'enfant au parent via des fonctions de rappel Props.
Les trois composants du projet de blog — NavBar, BlogCard et CategoryFilter — sont en place, et la structure du code est bien plus claire.
Autres extensions