Projet de synthèse — Semaine 3

Dashboard interactif · Thinking in React · Bonnes pratiques TypeScript

Composants · State · Composition · Listes · Patterns conditionnels

Objectifs de la leçon

1. Thinking in React

Appliquer la méthode officielle pour concevoir une UI

2. Réviser la semaine 3

JSX, composants, props, state, children, listes, keys

3. TypeScript utilitaires

Partial, Pick, Omit pour les props

4. Structure par feature

Organiser un projet React en dossiers par domaine

5. Bases de la performance

Comprendre quand un composant re-render et pourquoi

Plan du cours

1. Revue de la semaine

JSX, composants, props, state, children, listes, keys

2. Thinking in React

La méthode officielle pour concevoir une UI React

3. Démo live

Décomposer une maquette en arbre de composants

4. Bonnes pratiques TypeScript

Types utilitaires, generics basiques pour React

5. Mini-projet dashboard

Les étudiants codent l'après-midi

Revue de la semaine 3

Tous les concepts vus cette semaine — la base du projet

JSX & composants

Fonctions qui retournent du JSX — un composant = une responsabilité

Props

Données qui descendent du parent vers l'enfant — immuables

State

useState — données internes qui déclenchent un re-render

Children & composition

children prop — composer au lieu d'hériter

Listes & keys

.map() avec key stable et unique — jamais l'index

Rendu conditionnel

&&, ternaire, early return — choisir le bon pattern

Thinking in React — la méthode

5 étapes officielles pour concevoir une UI React

1️⃣

Découper en composants

Identifier les boîtes dans la maquette — un composant par responsabilité

2️⃣

Construire la version statique

Props only, pas de state — données codées en dur

3️⃣

Identifier le state

Quelles données changent dans le temps ? Le reste reste en props.

4️⃣

Déterminer où vit le state

Au plus bas niveau possible — le parent commun le plus proche

5️⃣

Ajouter l'interactivité

Handlers, inverse data flow — l'enfant remonte les changements au parent

Démo live — découper une maquette

Un dashboard typique : header, sidebar, cards, table, formulaire

# Arbre des composants

Dashboard

├── Header (title, user)

├── Sidebar (navItems, active)

├── StatsGrid

└── StatCard × 4 (label, value, trend)

├── OrdersTable (orders, onSort)

└── OrderRow × N (order, key)

└── AddOrderForm (onSubmit)

💡 Chaque boîte = un composant. On nomme les props qu'il faudra. On ne code rien encore.

Où vit le state ?

Règle d'or : le plus bas parent commun qui a besoin de ces données

✗ ERREUR

// TOUT dans App

function App() {

const [search, setSearch] = ...

const [sort, setSort] = ...

const [form, setForm] = ...

const [orders, setOrders] = ...

}

Prop drilling excessif — App devient un god component

✓ CORRECT

// State local quand possible

function AddOrderForm() {

const [form, setForm] = ... // ici

}

function OrdersTable() {

const [sort, setSort] = ... // ici

}

Chaque composant gère son propre state — App ne garde que l'essentiel

TypeScript — types utilitaires

Trois utilitaires indispensables pour typer les props React

type Order = {

id: string;

customer: string;

total: number;

status: 'pending' | 'paid';

};

// Tous les champs optionnels

type OrderDraft = Partial<Order>;

// Sélectionner certains champs seulement

type OrderSummary = Pick<Order, 'id' | 'total'>;

// Retirer un champ

type NewOrder = Omit<Order, 'id'>;

Typer les props — usage concret

Combiner les utilitaires avec React.FC ou une interface

// StatCard reçoit un sous-ensemble de Order

type StatCardProps = Pick<Order, 'total' | 'status'> & {

label: string;

};

function StatCard({ label, total, status }: StatCardProps) {

return (

<div>

<h3>{label}h3>

<p>{total}€ — {status}p>

div>

);

}

// Le formulaire crée un Order sans id

function AddOrderForm({ onSubmit }: { onSubmit: (o: NewOrder) => void }) {

// ...

}

Structure par feature

Organiser par domaine métier, pas par type de fichier

✗ Par type de fichier

src/

components/

Header.tsx

Sidebar.tsx

StatCard.tsx

OrderRow.tsx

hooks/

types/

utils/

On perd le contexte — un feature touche 5 dossiers

✓ Par feature

src/

features/

dashboard/

Header.tsx

Sidebar.tsx

orders/

OrdersTable.tsx

OrderRow.tsx

types.ts

shared/

ui/

Tout un feature vit au même endroit — facile à déplacer/supprimer

Bases de la performance

Quand un composant re-render — et pourquoi

Un composant re-render quand…

  • Son state change (appel à setX)
  • Ses props changent (nouvelle référence)
  • Son parent re-render — sauf si memo() est utilisé
  • Un context consommé change de valeur

Pour ce projet — ne pas optimiser prématurément

  • React est rapide par défaut pour des UI de cette taille
  • Mesurer avant d'optimiser (React DevTools Profiler)
  • Stabiliser les références des callbacks avec useCallback si besoin

Pièges courants

✗ Tout le state dans App

Prop drilling excessif — App devient un god component impossible à maintenir

⚠️ Composants trop petits ou trop gros

Un composant pour un seul

= bruit. Un composant de 300 lignes = illisible.

✗ Callbacks non typés

onSubmit: any — TypeScript ne peut plus vous aider. Toujours typer les props de fonction.

⚠️ Oublier l'état vide et les cas limites

Liste vide, chargement, erreur — pensez-y dès la maquette, pas à la fin

Le mini-projet — dashboard

Consigne de l'après-midi

🎯

Objectif

Un dashboard avec : 4 StatCards, une table d'orders triable, un formulaire d'ajout, une barre de recherche

🧠

Méthode

Appliquer Thinking in React : maquette → arbre → statique → state → interactivité

📐

Contraintes

TypeScript strict · structure par feature · typer les props avec Partial/Pick/Omit

✅

Livrable

Un repo qui tourne avec npm run dev — démo de 2 min à la fin

Points clés à retenir

🧠 Thinking in React : découper → statique → state → où vit le state → interactivité

🧱 Un composant = une seule responsabilité. S'il fait trop, découpe-le.

📍 Le state vit au plus bas niveau possible — pas tout dans App

🔧 Partial, Pick, Omit — les 3 utilitaires TypeScript à connaître

📁 Organiser par feature, pas par type de fichier