Informatique · JavaScript et front

React

Pour chaque morceau d'interface, tu décris l'écran qu'il doit afficher selon son état. Quand l'état change, React met la page à jour, au plus juste.

Déjà à l'aise ? Aller au quiz

Des morceaux qui changent, un écran qui suit.

Le principe

Chaque morceau garde son état, sa mémoire. Quand cet état change, React refait le rendu, puis met l'écran à jour.

étatcount = 0 JSXClics : 0 écranle bouton affiche 0 clicsetCount(…)

Ce cycle revient à chaque clic. C'est le cœur de React.

Après cette fiche, tu sais

  • écrire un composant en JSX et dire ce qui le compose : props, état, gestionnaires, rendu ;
  • expliquer ce qui se passe entre un clic et la mise à jour de l'écran ;
  • faire descendre des données par les props et remonter des événements par des fonctions ;
  • éviter les trois pièges classiques : clé de liste, état modifié sur place, hook dans une condition ;
  • utiliser useEffect sans boucle infinie, et placer React dans un site Astro.
Une devinette pour commencer : un bouton appelle trois fois setCount(count + 1) dans le même clic. Le compteur, parti de 0, affiche-t-il 3 ?

Oui, forcément ? Je ne suis pas sûr.

Garde ta réponse en tête : on la vérifie dans la notion 2, avec les trois appels.

Un morceau, une fonction

Notion 1 · Composants et JSX

Une fonction qui renvoie un morceau d'interface

React est une bibliothèque JavaScript créée chez Facebook (aujourd'hui Meta) et publiée en open source en 2013 ; la version actuelle est React 19.1 On y découpe l'interface en composants : des fonctions dont le nom commence par une majuscule, et qui renvoient du JSX.

<App /> <Header /><Liste /> LigneLigneLigne

Chaque composant renvoie la partie de l'écran dont il est responsable.

Réutiliser

Un composant se réutilise. La même fonction, appelée avec des props différentes, donne deux cartes différentes.

function Carte({ nom }) Léa<Carte nom="Léa" /> Zoé<Carte nom="Zoé" />

Le code ne change pas. Seule la prop nom change.

Sous le capot

Le JSX ressemble au HTML, mais il se compile en appels JavaScript qui créent des objets décrivant l'écran.9

<h1>Ma page</h1> appelJavaScript objetdécritl'écran React lit cet objet, puis met l'écran à jour.

Tu n'écris donc jamais de document.createElement à la main.

className, pas class

Dans le JSX, la classe CSS s'écrit className, car class est un mot réservé de JavaScript.

Événements en camelCase

onClick, onChange : le nom commence par on, puis chaque mot prend une majuscule.10

Balises toujours fermées

<img /> et <br /> : une balise vide se termine par />.

Des accolades pour le JavaScript

{nom}, {2 + 2}, {ok ? 'Oui' : 'Non'} : n'importe quelle expression, dans le texte ou un attribut.

Un composant, démonté

Fais défiler : le composant se découpe en quatre parties.

function Carte({ nom }) { const [ouverte, setOuverte] = useState(false); const basculer = () => setOuverte(!ouverte); return ( <article> <h2>{nom}</h2> <button onClick={basculer}> {ouverte ? 'Fermer' : 'Ouvrir'} </button> </article> ); } entrées : les props mémoire : l'état réaction : un gestionnaire sortie : le JSX Léa Ouvrir à l'écran, avec nom = "Léa"
Étape 1 sur 5

Un composant complet : une carte qui s'ouvre et se ferme. Tout tient dans une fonction.

Étape 2 sur 5 · les props

Les props sont les entrées du composant, fournies par son parent : ici, nom.

Étape 3 sur 5 · l'état

L'état est sa mémoire entre deux rendus : ouverte, et la fonction setOuverte pour le changer.

Étape 4 sur 5 · le gestionnaire

Un gestionnaire réagit à l'utilisateur : basculer demande l'inverse de la valeur actuelle.

Étape 5 sur 5 · le rendu

Le JSX renvoyé décrit l'écran pour ces props et cet état. React s'occupe du reste.

Un clic, un nouveau rendu

Notion 2 · L'état et le rendu

Un clic, un nouveau rendu

useState(0) crée une variable d'état qui vaut 0 au départ. Elle renvoie deux choses : la valeur actuelle, et une fonction pour la changer.

clic setCount(1)valeur notée nouveau renducount vaut 1 écran : 1

Appeler la fonction ne change pas la variable sur place : elle demande un nouveau rendu.

Une photo par rendu

rendu n° 1count = 0 setCount rendu n° 2count = 1 chaque rendu garde sa propre valeur

Chaque rendu a sa propre photo de l'état.

C'est ce que la documentation appelle l'état « instantané » : chaque rendu voit sa propre valeur, qui ne change jamais pendant ce rendu.2 Le rendu suivant reçoit la nouvelle valeur, pas celui en cours.

Du clic à l'écran

Fais défiler : React appelle le composant une nouvelle fois, puis compare le nouveau JSX à l'ancien.

function Compteur() { const [count, setCount] = useState(0); return ( <button onClick={() => setCount(count + 1)}> Clics : {count} </button> ); } ÉTAT count 0 rendu n° 1 suivant : 1 JSX RENVOYÉ <button> "Clics : 0" "Clics : 0" seule différence ÉCRAN Clics : 0
Étape 1 sur 6 · premier rendu

React appelle Compteur() : count vaut 0, le JSX décrit un bouton « Clics : 0 », React crée le bouton à l'écran.

Étape 2 sur 6 · le clic

Le gestionnaire appelle setCount(count + 1), soit setCount(1) : React note la valeur pour le prochain rendu.

Étape 3 sur 6 · nouveau rendu

React rappelle Compteur(). Cette fois, useState renvoie 1.

Étape 4 sur 6 · comparaison

React compare le nouveau JSX à l'ancien : seul le texte a changé, « Clics : 0 » devient « Clics : 1 ».

Étape 5 sur 6 · mise à jour

Il ne touche qu'à ce texte dans le DOM : le bouton lui-même n'est pas recréé.

Étape 6 sur 6 · une photo

Pendant un rendu, l'état est figé : juste après setCount(count + 1), count vaut encore 0 dans ce gestionnaire.

Trois setCount dans un même clic

Fais défiler : React met les mises à jour en file d'attente, puis les traite à la fin du gestionnaire. Compare les deux écritures.

Scène 1 · File d'attente

Version A

A · setCount(count + 1) × 3 B · setCount(c => c + 1) × 3 Départ : count = 0. Le rendu suivant reçoit le résultat de la file.

A …B …

Alors, il affiche 3, ou 1 ?

Je dirais 3, parce qu'on l'appelle trois fois !

Réponse : 1, pas 3. Les trois appels lisent le même count, qui vaut 0 pendant ce rendu. Pour enchaîner, passe une fonction : setCount(c => c + 1).3
Exercice · à toi

Que vaut count ?

Pour chaque gestionnaire, count vaut 0 avant le clic. Les trois cas ont été exécutés avec React 19.

Les données descendent, les clics remontent

Notion 3 · Props et flux de données

Les données descendent, les événements remontent

Un parent passe des props à ses enfants comme des attributs : <Carte nom="Léa" />.11 L'enfant les lit, mais ne les modifie jamais : elles sont en lecture seule.

Appnom = "Léa" nom Cartelit nom seulement modifier : interdit

Si un enfant doit changer une donnée, elle passe au parent, avec une fonction.12

Le parent

Le parent possède l'état. Il passe à Titre la prop nom, ainsi qu'une fonction pour la changer.

function App() {
  const [nom, setNom] = useState('Léa');
  return <Titre nom={nom} onRenommer={setNom} />;
}

L'enfant

L'enfant reçoit nom et onRenommer. Il n'a pas l'état : il appelle la fonction du parent.10

function Titre({ nom, onRenommer }) {
  return (
    <p>
      {nom}
      <button onClick={() => onRenommer('Zoé')}>Renommer</button>
    </p>
  );
}

L'aller et le retour

Fais défiler : la prop descend jusqu'au titre, le clic remonte jusqu'à App, puis la nouvelle valeur redescend.

Scène 2 · Flux de données

Premier rendu

<App /> état : nom = "Léa" <Header /> aucune prop <Carte /> nom, onRenommer <Avatar /> · <Titre /> Renommer "Léa" onRenommer

Exercice · à toi

Props ou état ?

Pour chaque donnée, dis si le composant la reçoit de son parent (props) ou s'en souvient lui-même (état).

Trois pièges à éviter

Notion 4 · Listes, immutabilité, règles des hooks

Trois pièges que React ne pardonne pas

  • Clé de liste. Dans items.map(item => <Ligne key={item.id} />), la key dit à React quel élément est lequel d'un rendu à l'autre. L'index du tableau comme clé provoque des bugs dès qu'on insère, supprime ou trie.4
  • État immuable. On ne modifie jamais un tableau ou un objet de l'état sur place (push, splice, affectation) : on en crée un nouveau, avec le spread [...todos, x], map ou filter.5
  • Règles des hooks. Les hooks s'appellent au niveau supérieur d'un composant ou d'un hook personnalisé, jamais dans une condition, une boucle ou une fonction imbriquée : React retrouve chaque état par l'ordre des appels.6

Référence

React compare les références : un tableau modifié sur place garde la même.

todos.push(x) tableau ALire, Coder, Tester même référence :React peut sauter le rendu [...todos, x] tableau Aancien, inchangé tableau BLire, Coder, Tester, x nouvelle référence : rendu

Clé de liste

Une clé d'index suit la position. Après l'insertion de « Œufs » en tête, la coche reste à la clé 0, donc passe à « Œufs ».

clé = index clé = identifiant 0 · Œufscoché : bug 1 · Laitpas coché 2 · Pain 3 · Café e · Œufsneuf a · Laitcoché : correct b · Pain c · Café

Un identifiant stable suit l'élément, quelle que soit sa position.

Les pièges, en direct

Fais défiler : chaque piège est joué dans sa version fautive, puis dans sa version correcte.

Scène 3 · Clé de liste

key = index

Attention

Les pièges classiques

Six erreurs fréquentes, à repérer d'un coup d'œil.

Modifier l'état sur place

todos.push(x) puis setTodos(todos) : même tableau, React peut sauter le rendu. Crée une copie : setTodos([...todos, x]).

L'index comme clé

Pour une liste qui change (insertion, suppression, tri), une clé d'index attache les états à la mauvaise ligne. Utilise un identifiant stable.

Un hook dans un if

L'ordre des appels change d'un rendu à l'autre, et React plante (« Rendered fewer hooks than expected »). Appelle toujours les hooks ; mets la condition dans le JSX.

Lire l'état juste après l'avoir changé

Après setCount(count + 1), count garde sa valeur dans ce rendu. La nouvelle valeur n'existe qu'au rendu suivant.

L'effet qui tourne en boucle

Un effet sans tableau de dépendances qui modifie l'état relance un rendu à l'infini. Donne les bonnes dépendances, ou calcule la valeur pendant le rendu.

Des classes Tailwind fabriquées

'text-' + couleur n'apparaît jamais en entier dans le code : Tailwind ne génère pas la classe. Écris les noms complets.

Se synchroniser avec le monde

Notion 5 · Les effets

useEffect : se synchroniser avec l'extérieur

Un rendu doit seulement calculer du JSX. Pour parler au monde extérieur (rejoindre une conversation, lancer un minuteur, s'abonner à un service), on utilise useEffect : son code s'exécute après la mise à jour de l'écran.7

renducalcul du JSX écranmise à jour effetuseEffect L'effet arrive toujours après l'écran.

Quand relancer

Le tableau de dépendances dit quand relancer l'effet. Chaque point du schéma est une exécution de l'effet.

useEffect(f) useEffect(f, []) useEffect(f, [salon]) salon change

Le nettoyage (la fonction renvoyée) s'exécute avant chaque nouvelle exécution, et au démontage.

Le nettoyage d'abord

Quand salon change, React quitte l'ancien salon avant de rejoindre le nouveau.

salon passe de « maths » à « info » 1. nettoyagequitter('maths') 2. effetrejoindre('info') l'ancien effet est nettoyé avant le nouveau
ÉcritureL'effet s'exécute…
useEffect(f)après chaque rendu
useEffect(f, [])une seule fois, après le premier rendu
useEffect(f, [salon])après le premier rendu, puis quand salon change

La vie d'un effet

Fais défiler : un composant de discussion rejoint un salon, en change, puis disparaît.

useEffect(() => { const connexion = rejoindre(salon); return () => connexion.quitter(); }, [salon]); EN DÉVELOPPEMENT, MODE STRICT rejoindre('maths') quitter('maths') rejoindre('maths') React teste ton nettoyage au montage
Étape 1 sur 5 · le montage

Premier rendu, l'écran se met à jour, puis l'effet s'exécute : le composant rejoint le salon « maths ».

Étape 2 sur 5 · la dépendance change

Le salon passe à « info ». Après le rendu, React lance d'abord le nettoyage de l'ancien effet, puis le nouvel effet.

Étape 3 sur 5 · autre changement

Un autre état change, mais pas salon : nouveau rendu, et aucun effet relancé.

Étape 4 sur 5 · le démontage

Le composant disparaît de l'écran : son dernier nettoyage s'exécute, le salon « info » est quitté.

Étape 5 sur 5 · en développement

En mode strict, React monte, démonte puis remonte le composant une fois de plus, exprès : un bon nettoyage rend ce test invisible.

Et sans tableau de dépendances, si l'effet modifie l'état ?

Il tourne après chaque rendu, donc sans fin ?

Oui. Chaque rendu relance l'effet, qui provoque un nouveau rendu, et ainsi de suite. React finit par s'arrêter avec l'erreur « Maximum update depth exceeded ».

Avant d'écrire un effet

Demande-toi s'il en faut un. Une valeur qui se calcule à partir des props ou de l'état (un total, une liste filtrée) se calcule directement pendant le rendu, sans effet ni état supplémentaire.14

Partager sans tout passer

Notion 6 · Contexte et autres hooks

Partager sans tout passer à la main

Passer une prop à travers cinq composants qui ne s'en servent pas, c'est le « prop drilling ». Le contexte rend une valeur accessible à tout un sous-arbre.13

Prop drilling AppPage ListeCarte Bouton la prop passe par chaque niveau Contexte ThemeContext useContext Bouton le bouton lit la valeur, sans intermédiaire

On le crée avec createContext, on l'entoure autour des composants, et on le lit avec useContext. Depuis React 19, le contexte s'utilise directement comme composant fournisseur.

Le hook use, nouveauté de React 19, lit un contexte ou une promesse, et peut même être appelé dans une condition.17

un thème pour toute l'applijsx
const ThemeContext = createContext('clair');

function App() {
  return (
    <ThemeContext value="sombre">
      <Barre />
    </ThemeContext>
  );
}
function BoutonTheme() {
  const theme = useContext(ThemeContext); // "sombre"
  return <button className={theme}>Bouton</button>;
}

Mémoire sans rendu

Un useRef garde une valeur entre les rendus, sans relancer l'écran. C'est la place idéale pour l'identifiant d'un minuteur.18

useState setCount(2) nouveau rendu useRef ref.current = 2 pas de nouveau rendu l'écran ne bouge pas
HookÀ quoi il sert
useRefgarder une valeur entre les rendus sans en déclencher (l'identifiant d'un minuteur, un élément du DOM)
useReducerun état complexe modifié par des actions ({ type: 'ajouter' })
useMemo, useCallbackmémoriser un calcul coûteux ou une fonction entre deux rendus
useIdun identifiant stable, pour relier un label et son champ
useTransitionmarquer une mise à jour comme non urgente pour garder l'interface fluide
use (React 19)lire une promesse ou un contexte pendant le rendu ; seule API de ce genre qu'on peut appeler dans une condition

Du HTML, et des îlots

Notion 7 · React dans un projet

Astro, Tailwind et un carrousel

Astro est un outil de construction de sites. Il rend chaque composant en HTML et CSS, et retire par défaut tout le JavaScript côté client. Un composant React ne devient interactif que si tu le demandes avec une directive client:* : il forme alors un îlot, qui charge son JavaScript à part.8

en-tête : HTML statique, aucun JavaScript <Carrouselclient:visible />îlot : quand il apparaît <Panierclient:load />îlot : tout de suite pied de page : HTML statique

Trois directives

Chaque directive dit à quel moment le JavaScript du composant se charge.

DirectiveLe JavaScript du composant se charge…
client:loadtout de suite, au chargement de la page
client:idlequand le navigateur n'a plus rien d'urgent à faire
client:visiblequand le composant entre dans l'écran

Dans une page Astro, le composant s'importe, puis reçoit sa directive.

src/pages/index.astroastro
---
import Compteur from '../components/Compteur.jsx';
---
<h1>Ma page</h1>
<Compteur client:visible />

Tailwind CSS

Tailwind style les composants avec des classes utilitaires (className="px-4 py-2 rounded-lg"). Piège : Tailwind repère les classes en lisant ton code source, il faut donc écrire chaque nom de classe en entier.15

'text-' + couleurpas trouvée : non générée text-red-600trouvée : générée Le nom complet doit apparaître dans tes fichiers.

Donc 'bg-' + couleur + '-600' ne sera jamais généré ; un objet { danger: 'bg-red-600', ok: 'bg-green-600' }, si.

Embla Carousel

Embla fournit un carrousel léger : on installe embla-carousel-react, puis le hook useEmblaCarousel({ loop: true }) renvoie une référence à poser sur le conteneur.16

1 2 3 1 Diapositive 1, puis 2 : le carrousel défile.

Options utiles : loop (boucle infinie), align (alignement des diapositives), slidesToScroll (combien défilent à la fois), dragFree (glissement libre).

Cherche d'abord, puis corrige

Entraîne-toi

Exercices corrigés

Cherche d'abord, puis ouvre le corrigé. Chaque corrigé a été exécuté avec React 19.3.

1Écris un composant Interrupteur : un bouton qui affiche « Éteint » et passe à « Allumé » au clic, puis l'inverse.Voir le corrigé
function Interrupteur() {
  const [allume, setAllume] = useState(false);
  return (
    <button onClick={() => setAllume(!allume)}>
      {allume ? 'Allumé' : 'Éteint'}
    </button>
  );
}
2Un état eleves contient une liste d'objets { id, nom }. Écris la fonction retirer(id) qui enlève un élève, sans modifier le tableau sur place.Voir le corrigé
const retirer = (id) => setEleves(eleves.filter((e) => e.id !== id));

filter crée un nouveau tableau sans l'élève : React voit une nouvelle référence et met la liste à jour. Avec splice, le tableau serait modifié sur place.

3Pourquoi ce composant ralentit-il le navigateur jusqu'à l'erreur ? useEffect(() => { setN(n + 1); });Voir le corrigé

Sans tableau de dépendances, l'effet s'exécute après chaque rendu ; il change l'état, ce qui provoque un nouveau rendu, qui relance l'effet… En une demi-seconde, notre essai a enchaîné plus de 5000 rendus avant que React signale « Maximum update depth exceeded ». Il faut un tableau de dépendances adapté, ou pas d'effet du tout.

4Que vaut n après un clic sur ce bouton, si n vaut 0 ? onClick={() => { setN(n + 5); setN(m => m + 1); }}Voir le corrigé

6. La file contient « remplacer par 0 + 5 », puis « ajouter 1 à la valeur précédente » : 5, puis 6.

Pour tout réunir

Une liste de tâches complète

Ajouter, cocher et supprimer des tâches : état, gestionnaires, copies immuables (spread, map, filter), clés stables. Testé avec React 19.3.

Le flux

saisiechamp de texte setTodos([...])nouvelle copie listeà l'écran cocher ou supprimer : une autre copie
TodoApp.jsxjsx
import { useState } from 'react';

export default function TodoApp() {
  const [todos, setTodos] = useState([]);
  const [input, setInput] = useState('');

  const ajouter = () => {
    if (!input.trim()) return;
    setTodos([...todos, { id: Date.now(), texte: input, fait: false }]);
    setInput('');
  };
  const basculer = (id) =>
    setTodos(todos.map((t) => (t.id === id ? { ...t, fait: !t.fait } : t)));
  const supprimer = (id) => setTodos(todos.filter((t) => t.id !== id));

  return (
    <div>
      <input value={input} onChange={(e) => setInput(e.target.value)}
             onKeyDown={(e) => e.key === 'Enter' && ajouter()} />
      <button onClick={ajouter}>Ajouter</button>
      <ul>
        {todos.map((t) => (
          <li key={t.id}>
            <input type="checkbox" checked={t.fait}
                   onChange={() => basculer(t.id)} />
            <span className={t.fait ? 'fait' : ''}>{t.texte}</span>
            <button onClick={() => supprimer(t.id)}>Supprimer</button>
          </li>
        ))}
      </ul>
    </div>
  );
}

À retenir

La fiche en huit lignes

Composantune fonction à majuscule qui renvoie du JSX ; props en entrée, état en mémoire, gestionnaires, rendu.
ÉtatuseState ; la fonction de mise à jour demande un nouveau rendu ; pendant un rendu, l'état est figé.
File d'attentetrois setCount(count + 1) donnent 1 ; trois setCount(c => c + 1) donnent 3.
Propsen lecture seule ; les données descendent, les événements remontent par des fonctions.
Listesune key stable par élément (un id, pas l'index si la liste change).
Immutabilitéjamais de push sur l'état : spread, map, filter créent un nouveau tableau.
Hooks et effetshooks au niveau supérieur ; useEffect après l'affichage, avec dépendances et nettoyage.
AstroHTML sans JavaScript par défaut ; client:load, client:idle, client:visible créent des îlots.

Douze questions pour finir

Au quiz ! Plusieurs questions reprennent les pièges : si tu as suivi les scènes, tu les vois venir.
Quiz final

Teste-toi

Sources

  1. React, React Versions (React publié en open source chez Facebook en 2013 ; dernière version : 19.3.0, 9 septembre 2026 ; React 19.0.0 : décembre 2024). react.dev, consulté le 8 octobre 2026.
  2. React, L'état est un instantané (définir l'état ne le change que pour le prochain rendu ; la valeur ne change jamais au sein d'un rendu). fr.react.dev, consulté le 8 octobre 2026.
  3. React, Cumuler les mises à jour d'un même état (fonction de mise à jour, traitement en lot à la fin du gestionnaire). fr.react.dev, consulté le 8 octobre 2026.
  4. React, Afficher des listes (rôle des clés ; l'index comme clé entraîne des bugs quand l'ordre change). fr.react.dev, consulté le 8 octobre 2026.
  5. React, Mettre à jour les tableaux d'un état (tableaux de l'état en lecture seule ; filter, map et spread plutôt que push et splice). fr.react.dev, consulté le 8 octobre 2026.
  6. React, Les règles des Hooks (pas de hooks dans les boucles, conditions et fonctions imbriquées ; seulement dans les composants et hooks personnalisés). fr.react.dev, consulté le 8 octobre 2026.
  7. React, Synchroniser grâce aux Effets (exécution après le rendu, dépendances, nettoyage avant l'exécution suivante et au démontage, double montage du Mode strict en développement). fr.react.dev, consulté le 8 octobre 2026.
  8. Astro, Architecture en îlots (composants rendus en HTML et CSS sans JavaScript côté client ; directives client:load, client:idle, client:visible). docs.astro.build, consulté le 8 octobre 2026.
  9. React, Écrire du balisage avec JSX (className, balises fermées, accolades pour le JavaScript). fr.react.dev, consulté le 8 octobre 2026.
  10. React, Réagir aux événements (gestionnaires, noms d'événements en camelCase, fonctions passées en prop). fr.react.dev, consulté le 8 octobre 2026.
  11. React, Passer des props à un composant (props transmises par le parent, en lecture seule pour l'enfant). fr.react.dev, consulté le 8 octobre 2026.
  12. React, Partager l'état entre des composants (l'état est placé dans le parent ; l'enfant appelle une fonction reçue en prop). fr.react.dev, consulté le 8 octobre 2026.
  13. React, Transmettre des données en profondeur avec le contexte (prop drilling, createContext, useContext, fournisseur). fr.react.dev, consulté le 8 octobre 2026.
  14. React, Vous n'avez pas forcément besoin d'un Effet (valeurs calculées pendant le rendu, sans effet). fr.react.dev, consulté le 8 octobre 2026.
  15. Tailwind CSS, Detecting classes in source files (Tailwind lit le code source pour générer les classes utilisées). tailwindcss.com, consulté le 8 octobre 2026.
  16. Embla Carousel, Options (loop, align, slidesToScroll, dragFree). embla-carousel.com, consulté le 8 octobre 2026.
  17. React, use (lecture d'une promesse ou d'un contexte pendant le rendu ; appel possible dans une condition), et React Blog, React v19, 5 décembre 2024 (nouvelle API use, introduite avec React 19). fr.react.dev · react.dev, consulté le 8 octobre 2026.
  18. React, useRef (référence qui garde une valeur entre les rendus, sans déclencher de rendu). fr.react.dev, consulté le 8 octobre 2026.

Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Tous les exemples de code exécutés avec React 19.3.0 et ReactDOM 19.3.0 (Chrome, builds de production et de développement) ; options d'Embla Carousel vérifiées dans les définitions du paquet 8.6.0.

Glisser pour continuer vers HTTP et REST