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 pageFaut-il le découper en un composant ?Raison
Barre de navigationOuiChaque page en a besoin ; fonctionnalité indépendante
Carte d'articleOuiChaque article de la liste a la même structure
Groupe de boutons de filtrage par catégorieOuiPossède son propre état et ses propres interactions
Conteneur d'encapsulation simplenonUniquement 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

// Chemin du fichier : src/components/BlogCard.jsx
// 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

// Chemin du fichier : src/App.jsx
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

// Chemin du fichier : src/components/CategoryFilter.jsx
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 { useState } from 'react'
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énarioVue3React
Du parent à l'enfantProps(defineProps)Props (paramètres de fonction)
De l'enfant au parentÉmettre un événementFonction de rappel via props
Direction des donnéesUnidirectionnelUnidirectionnel

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

// Props avec valeurs par défaut
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

// Chemin du fichier : src/components/NavBar.jsx
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

// Chemin du fichier : src/App.jsx
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