Aller au contenu
Encyclopédie informatique Édition 2026

Les frameworks web : React, Vue, Angular et Node.js

Partie 2 sur 3

Niveau de lecture :

4Les idées communes

4.1Les composants

Tous les frameworks modernes découpent l’interface en composants : des morceaux autonomes et réutilisables, qui regroupent leur structure, leur apparence et leur comportement. Une page de boutique se décompose en un en-tête, qui contient un logo et un panier, une liste de produits, qui contient des cartes, chacune avec un bouton, et un pied de page (figure 1). Les composants s’emboîtent et forment un arbre ; chacun reçoit des données de son parent, appelées propriétés, et peut signaler des événements, comme un clic, à ses ancêtres.

LA PAGE Boutique rechercher… panier 3 Lampe 24 € ajouter Tasse 9 € ajouter Carnet 6 € ajouter pied de page SON ARBRE DE COMPOSANTS App EnTete ListeProduits Pied Logo Panier Carte Carte Carte Bouton état : panier = [lampe, tasse, carnet] un clic sur « ajouter » modifie l’état ; Panier se met à jour
Figure 1. Une interface se décompose en un arbre de composants ; un changement d’état met à jour les composants concernés.

4.2L’interface en fonction de l’état

Deuxième idée clé : on ne dit plus au navigateur quoi modifier, on décrit à quoi l’interface doit ressembler pour un état donné, c’est-à-dire l’ensemble des données qui peuvent changer : le contenu du panier, l’utilisateur connecté, le texte saisi. Quand l’état change, le framework recalcule l’affichage et applique lui-même les modifications nécessaires au DOM. C’est le style déclaratif, souvent résumé par la formule « l’interface est une fonction de l’état ». Le même compteur, écrit avec React, utilise une syntaxe appelée JSX, qui mêle balises HTML et JavaScript :

import { useState } from "react";

function Compteur() {
  const [n, setN] = useState(0);        // un état, initialisé à 0
  return (
    <button onClick={() => setN(n + 1)}>
      Cliqué {n} fois
    </button>
  );
}

Et avec Vue, qui sépare un gabarit HTML et un script :

<script setup>
import { ref } from "vue";
const n = ref(0);                        // une donnée réactive
</script>

<template>
  <button @click="n++">Cliqué {{ n }} fois</button>
</template>

Dans les deux cas, le code ne touche jamais au DOM : il modifie l’état, et l’affichage suit. Pour un compteur, le gain est nul ; pour une application de cent écrans, il est considérable.

4.3Comment l’affichage suit

Les frameworks diffèrent par la façon dont ils détectent ce qui doit changer. React recalcule à chaque changement d’état une représentation légère de l’interface du composant concerné et de ses descendants, appelée DOM virtuel, la compare à la précédente, et n’applique au vrai DOM que les différences : c’est la réconciliation. Simple à comprendre, cette approche peut recalculer beaucoup de choses inutilement, ce que les développeurs, et depuis 2024 un compilateur conçu pour React, cherchent à éviter.

Vue et les frameworks fondés sur les signaux, comme Solid, Angular dans ses versions récentes ou Svelte depuis sa version 5, suivent une autre voie : chaque donnée réactive sait quels morceaux d’affichage dépendent d’elle, et seuls ceux-là sont mis à jour quand elle change. Svelte va plus loin en faisant ce travail à la compilation : le code envoyé au navigateur modifie directement les bons éléments du DOM, sans couche intermédiaire, ce qui donne des applications légères. Ces différences comptent pour les interfaces très dynamiques ; pour la plupart des applications, tous les grands frameworks sont assez rapides.

4.4Les applications monopages et le routage

Avec un framework côté client, on peut construire une application monopage (en anglais Single Page Application, SPA) : le navigateur charge une seule page, puis le framework affiche les différents écrans sans recharger, en récupérant seulement les données nécessaires auprès d’une interface de programmation (voir les API). Un routeur fait correspondre chaque adresse, comme /produits/42, à l’écran à afficher, et met à jour la barre d’adresse pour que le bouton « précédent » et les favoris fonctionnent. L’expérience est fluide, mais le premier chargement peut être lent, et les pages mal visibles pour les moteurs de recherche : d’où les autres modes de rendu.

4.5Gérer l’état d’une application

Dans une petite application, chaque composant garde son propre état, et les données descendent de parent en enfant. Dans une grande application, certaines données sont utilisées partout : l’utilisateur connecté, ses préférences, le panier. Les faire passer de composant en composant sur dix niveaux devient fastidieux. On utilise alors un magasin d’état (en anglais store), un objet central auquel tous les composants peuvent s’abonner : Redux ou Zustand pour React, Pinia pour Vue, les services d’Angular. Une autre catégorie de données mérite un traitement à part : celles qui viennent du serveur, comme une liste de produits. Des bibliothèques spécialisées les récupèrent, les gardent en cache, les rafraîchissent quand elles vieillissent et gèrent les états de chargement et d’erreur, ce qui évite d’écrire ce code délicat à la main dans chaque composant. Enfin, les formulaires, avec leurs validations et leurs messages d’erreur, ont aussi leurs bibliothèques dédiées. Bien répartir l’état, local, partagé ou issu du serveur, est l’une des principales difficultés de conception d’une application Web.

Pour s’exercer

Exercice 1 : découper en composants

Découpez en composants la page d’une messagerie : une liste des conversations à gauche, avec pour chacune le nom, la photo et le dernier message ; à droite, la conversation ouverte, avec ses messages et une zone de saisie. Quel état faut-il, et où le placer ?

Voir la réponse

Par exemple : App contient ListeConversations, qui contient des ApercuConversation avec un Avatar ; et Conversation, qui contient des Message et une ZoneSaisie. L’état comprend la liste des conversations, l’identifiant de la conversation ouverte, les messages de celle-ci et le texte en cours de saisie. La conversation ouverte est utilisée à la fois par la liste, pour la mettre en évidence, et par la partie droite : on la place dans leur ancêtre commun, App. Le texte en cours de saisie ne concerne que ZoneSaisie : il reste local à ce composant. Règle générale : placer chaque état au plus bas niveau possible, mais assez haut pour être partagé par tous les composants qui en ont besoin.

Exercice 2 : impératif ou déclaratif ?

Dans une boutique sans framework, le nombre d’articles du panier s’affiche dans l’en-tête, dans le bas de page et sur le bouton « commander ». Un développeur ajoute une fonction de suppression d’article, mais oublie de mettre à jour le bas de page. Comment un framework évite-t-il ce bogue ?

Voir la réponse

Dans le style impératif, chaque modification doit mettre à jour à la main chaque endroit où la donnée s’affiche : la moindre omission rend l’affichage incohérent. Avec un framework, le panier est un état unique ; les trois composants affichent une valeur calculée à partir de cet état. Supprimer un article modifie l’état, et le framework met à jour automatiquement tous les composants qui en dépendent, y compris ceux ajoutés plus tard. La cohérence n’est plus de la responsabilité du développeur à chaque modification.

5Où se construit la page ?

Une question centrale des frameworks récents est de savoir où et quand le HTML de la page est produit (figure 2) :

  • le rendu côté client (en anglais Client-Side Rendering, CSR) : le serveur envoie une page presque vide et un gros programme JavaScript, qui construit tout dans le navigateur. Rien ne s’affiche tant que le script n’est pas téléchargé et exécuté ;
  • le rendu côté serveur (en anglais Server-Side Rendering, SSR) : le serveur exécute les composants à chaque visite et envoie une page complète, qui s’affiche immédiatement ; le JavaScript arrive ensuite et prend le relais pour rendre la page interactive, une étape appelée hydratation ;
  • la génération statique (en anglais Static Site Generation, SSG) : les pages sont construites une fois pour toutes lors de la publication, puis servies telles quelles, très rapidement, par n’importe quel hébergement simple ou réseau de diffusion de contenu. Idéal pour les contenus qui changent peu : documentation, blog, site vitrine, encyclopédie.
RENDU CÔTÉ CLIENT page vide + gros JS téléchargement et exécution du JavaScript contenu visible et interactif RENDU CÔTÉ SERVEUR le serveur construit la page contenu visible hydratation interactif GÉNÉRATION STATIQUE page prête contenu visible interactif (peu de JS) temps demande de la page Statique : construite une fois, au déploiement. Serveur : à chaque visite. Client : dans le navigateur.
Figure 2. Plus la page est préparée tôt, plus elle s’affiche vite.

Les frameworks complets permettent de mélanger ces modes page par page, et proposent des variantes : régénérer périodiquement des pages statiques, envoyer la page par morceaux au fur et à mesure qu’ils sont prêts, ou n’hydrater que les parties interactives, les îlots, en laissant le reste en HTML pur. Les composants serveur de React vont jusqu’à exécuter certains composants uniquement sur le serveur, où ils peuvent interroger directement une base de données, sans envoyer leur code au navigateur. Ces techniques améliorent la vitesse d’affichage, l’accessibilité et le référencement, mais brouillent la frontière entre client et serveur : il faut savoir à chaque instant où s’exécute le code, ce qui a des conséquences pour la sécurité (coin cyber).

Pour comparer ces choix, on mesure l’expérience réelle des visiteurs. Google a popularisé trois indicateurs, les Core Web Vitals : le temps d’affichage du plus grand élément visible de la page, la réactivité de la page aux actions de l’utilisateur, et la stabilité de la mise en page, qui ne doit pas sauter pendant le chargement. Ces indicateurs comptent pour le confort des utilisateurs, et aussi pour le classement dans les moteurs de recherche (voir le référencement). Ils se mesurent sur de vrais appareils, y compris des téléphones modestes, et pas seulement sur l’ordinateur puissant du développeur.

Pour s’exercer

Exercice 3 : choisir le mode de rendu

Quel mode de rendu choisir pour : (a) la documentation d’un logiciel, mise à jour chaque semaine ; (b) un tableau de bord interne réservé aux salariés connectés ; (c) la page d’un produit dans une grande boutique en ligne, dont le prix et le stock changent souvent et qui doit être bien référencée ?

Voir la réponse

(a) La génération statique : les pages sont construites à chaque publication et servies très vite, sans serveur applicatif à maintenir. (b) Le rendu côté client convient : le référencement est inutile, les utilisateurs reviennent souvent, et l’application est très interactive. (c) Le rendu côté serveur, ou une page statique régénérée régulièrement, avec le prix et le stock chargés à part : la page doit s’afficher vite, être lisible par les moteurs de recherche et rester à jour.