Svelte stores : comment partager un état entre plusieurs composants ?
Partager un compteur, un panier ou les préférences d’affichage entre plusieurs composants est une étape fréquente dans un projet Svelte. Le défi consiste à faire circuler une même donnée sans multiplier les propriétés transmises de parent en enfant, tout en gardant un code facile à comprendre et à faire évoluer.
Les stores restent une solution utile, notamment lorsqu’une valeur doit être observée explicitement ou qu’elle possède son propre cycle de démarrage et d’arrêt. Avec Svelte 5, ils cohabitent toutefois avec d’autres outils réactifs, comme les runes et le contexte. Le bon choix dépend de la portée de l’état, de la structure des composants et du mode de rendu de l’application.
En bref
- writable convient à une valeur partagée et modifiable, comme le nombre d’articles dans un panier.
- Le préfixe $ permet de lire un store de façon réactive dans un composant Svelte et, pour un store modifiable, d’actualiser sa valeur.
- readable expose une donnée qui ne se modifie pas directement depuis les composants, par exemple une horloge.
- derived calcule une valeur à partir d’un ou plusieurs stores existants.
- Dans Svelte 5, les stores ne sont plus l’unique approche privilégiée pour tout état partagé : props, contexte et état réactif de module ont aussi leur place.
Choisir les stores Svelte selon la portée de l’état partagé
Un état partagé est une donnée utilisée par plusieurs parties d’une interface. Imaginez une boutique en ligne : le compteur du panier apparaît dans l’en-tête, tandis que le détail des articles est affiché sur une page dédiée. Si chaque composant conserve sa propre copie du nombre d’articles, les deux affichages peuvent diverger après une modification.
Un store permet de centraliser cette valeur et de la rendre accessible à plusieurs composants. Avant Svelte 5, c’était l’approche idiomatique pour gérer un état réactif en dehors d’un composant. Aujourd’hui, les stores sont toujours pris en charge et restent utiles, mais ils s’inscrivent dans un éventail plus large d’outils. La gestion d’état gagne à commencer par une question simple : qui doit lire ou modifier la donnée, et pendant combien de temps ?
Si deux composants voisins échangent une information ponctuelle, les props sont souvent suffisantes. L’état peut être placé dans leur parent commun, puis transmis aux enfants concernés. Cette organisation, parfois appelée remontée de l’état, est directe et rend les dépendances visibles dans la structure de l’interface. Elle devient moins pratique lorsque la valeur doit traverser de nombreux niveaux qui ne l’utilisent pas eux-mêmes.
Le contexte répond à un autre besoin : fournir une valeur à des composants descendants sans la faire passer comme prop à chaque étape. Il est associé à un arbre de composants précis. En revanche, si deux composants appartiennent à des arbres distincts, un module partagé ou un store peut mieux convenir. Pour situer ces choix dans un projet concret, un tutoriel pour créer une web app avec Svelte peut aider à comprendre comment organiser progressivement les composants et leurs données.
Les stores se distinguent surtout par leur modèle d’abonnement : un composant qui les lit réagit aux changements de valeur. Cela évite de synchroniser manuellement plusieurs copies, mais ne signifie pas qu’il faut transformer chaque variable en store. Un état limité à un formulaire ou à une petite partie de page reste généralement mieux placé au plus près de son usage. La portée de la donnée doit déterminer l’outil, plutôt que l’envie d’ajouter un mécanisme global.

Créer un store writable et le partager entre composants
Pour une valeur que plusieurs composants doivent pouvoir modifier, Svelte fournit writable, exporté par svelte/store. Le store peut être placé dans un module JavaScript séparé afin que les composants concernés importent exactement la même instance. Dans une boutique, ce module pourrait contenir le nombre d’articles du panier, plutôt qu’une valeur isolée dans l’en-tête et une autre dans la page du panier.
Le module peut exporter un store initialisé, par exemple avec la valeur 0. Un composant qui l’importe peut alors afficher son contenu en préfixant le nom du store par le signe $. Dans le balisage, l’expression {$count} affiche la valeur actuelle. Le préfixe signale à Svelte qu’il faut suivre le store et mettre à jour l’affichage lorsque sa valeur change.
Une confusion courante consiste à afficher directement l’objet store au lieu de sa valeur. L’interface risque alors de montrer une représentation d’objet, telle que [object Object], au lieu du nombre attendu. La lecture réactive avec le préfixe $ est donc essentielle dans le composant. Il faut aussi respecter la syntaxe adaptée à la version de Svelte employée : les exemples de gestionnaire d’événement peuvent différer entre les anciens projets et les conventions de Svelte 5.
Un store writable propose deux méthodes pour changer la donnée depuis le code. La méthode set remplace la valeur par une nouvelle : elle est adaptée lorsque la valeur cible est déjà connue. La méthode update reçoit la valeur actuelle et retourne la suivante. Pour incrémenter un compteur, la logique peut prendre la forme suivante : update(n => n + 1). Cette opération exprime clairement que le résultat dépend de l’état existant, ce qui évite de calculer une nouvelle valeur à partir d’une copie possiblement périmée.
Dans un composant Svelte, l’écriture via $count peut aussi simplifier une modification effectuée dans un gestionnaire, par exemple une augmentation d’une unité. La mise à jour se répercute alors sur les autres composants qui affichent ce même store. Si le changement exige une règle métier plus complexe, comme empêcher un panier de dépasser une limite, il est préférable de centraliser cette règle dans une fonction dédiée plutôt que de laisser chaque composant appliquer sa propre variante.
Un module partagé doit être importé depuis un chemin cohérent pour garantir que les composants utilisent la même instance. Il faut également éviter de confondre la valeur du store avec le store lui-même : la première sert à l’affichage ou au calcul, le second fournit les opérations de lecture et de mise à jour. Un store writable est efficace lorsque plusieurs composants partagent réellement une donnée modifiable et que ses règles de changement restent explicites.
Comprendre readable, derived et la souscription
Tous les stores n’ont pas vocation à être modifiés depuis un composant. Un store readable expose une valeur consultable sans fournir les méthodes set et update à son consommateur. Il est approprié pour une donnée produite par un mécanisme autonome, comme une horloge, une mesure d’activité ou l’état fourni par un service externe. La distinction réduit les risques de modification accidentelle et clarifie qui contrôle la valeur.
Un readable peut recevoir une valeur initiale et une fonction de démarrage. Cette fonction reçoit notamment une opération permettant d’émettre de nouvelles valeurs. Elle peut démarrer un intervalle, établir une connexion ou lancer une autre activité nécessaire à la production des données. La fonction peut également retourner un nettoyage, appelé lorsque plus aucun composant n’est abonné. Pour un minuteur, cela permet de démarrer le tic-tac lorsqu’un composant en a besoin, puis d’arrêter l’intervalle lorsque l’observation prend fin.
Cette gestion du cycle de vie est l’un des intérêts importants des stores. Elle évite de faire tourner une tâche en arrière-plan sans nécessité et rassemble au même endroit la logique de production et son nettoyage. Dans un exemple d’horloge, les composants affichent la valeur réactive, tandis que le store gère l’intervalle. L’interface n’a pas besoin de connaître les détails du mécanisme qui actualise l’heure.
Un store derived calcule une valeur à partir d’un autre store ou de plusieurs stores. Dans une boutique, le total du panier peut être calculé à partir de la liste des articles, ou un message d’accueil peut dépendre du nom d’utilisateur. Le résultat est actualisé lorsque les sources changent. Cette approche évite de stocker séparément une donnée calculable, ce qui limiterait les risques d’incohérence entre la source et son dérivé.
Dans Svelte 5, certaines valeurs dérivées peuvent également être exprimées avec les runes réactives, notamment $derived à partir d’un état compatible. Le choix dépend du contexte : si l’application utilise déjà des stores, derived s’intègre naturellement à cette organisation. Si l’état partagé est construit avec les outils réactifs de Svelte 5, conserver la même approche peut rendre le code plus homogène. Une migration n’exige donc pas de remplacer mécaniquement tous les stores existants.
Il est aussi possible d’utiliser la méthode subscribe pour réagir explicitement à une nouvelle valeur, par exemple pour déclencher une opération non visuelle. La souscription doit toutefois être gérée avec attention : lorsqu’elle est créée manuellement, son nettoyage doit être prévu pour éviter qu’elle ne survive inutilement à son usage. Dans un composant, la lecture via $ prend généralement en charge l’abonnement et son cycle de vie. Readable protège la production d’une valeur, derived évite les duplications et la souscription explicite répond aux besoins qui dépassent le simple affichage.
Les notions de stores prennent tout leur sens lorsque la réactivité n’est pas seulement visible dans un compteur, mais soutient des comportements durables comme un flux d’activité ou une donnée calculée.
Comparer stores, props, contexte et état partagé avec Svelte 5
Un store n’est pas toujours la voie la plus courte. Pour un état utilisé par un parent et quelques enfants directs, les props exposent clairement qui fournit la donnée et qui la reçoit. Pour des descendants éloignés dans le même arbre, le contexte évite le passage répété de props intermédiaires. Pour un état réactif importé depuis plusieurs composants, un module Svelte 5 peut également convenir, tandis que les stores restent utiles lorsque l’abonnement explicite ou une logique de démarrage et d’arrêt est souhaitée.
Avec le contexte, setContext associe une valeur à une clé dans un composant fournisseur, puis getContext permet à un descendant de la récupérer. Cette relation reste limitée à l’arbre concerné : un composant situé dans une autre branche qui n’est pas descendante ne peut pas récupérer ce contexte de la même manière. Le contexte est donc particulièrement adapté à une zone d’interface cohérente, comme un éditeur avec plusieurs panneaux qui ont besoin des mêmes paramètres.
Svelte 5 permet aussi d’exporter un objet réactif depuis un fichier de module adapté, comme un fichier .svelte.js. Plusieurs composants peuvent importer cet objet et lire ses propriétés sans utiliser le préfixe $ des stores. Cette option convient par exemple à un thème partagé ou à un panier dans un contexte client. La réactivité porte sur les propriétés de l’objet ; il faut donc éviter de réassigner l’objet exporté lui-même et modifier plutôt les propriétés prévues.
| Approche | Portée adaptée | Point de vigilance |
|---|---|---|
| Props | Parent et enfants proches | Le passage à travers plusieurs niveaux peut devenir répétitif. |
| Contexte | Descendants d’un même composant fournisseur | Il ne relie pas directement des arbres distincts. |
| État réactif de module | État partagé entre modules en Svelte 5 | Éviter les données personnelles partagées côté serveur. |
| Stores | Abonnement explicite, sources autonomes ou code déjà fondé sur les stores | Choisir le type adapté et gérer le cycle de vie des abonnements manuels. |
Le rendu côté serveur impose une précaution importante avec un module partagé. En SvelteKit, un serveur peut traiter plusieurs requêtes : une valeur de module contenant des informations propres à un utilisateur pourrait alors être partagée entre des requêtes si elle est utilisée sans isolation. Pour des données individuelles côté serveur, les props et le contexte, utilisés dans le périmètre de la requête, sont des choix plus sûrs. Une donnée globale côté navigateur, comme la préférence de thème après chargement, pose un problème différent, mais doit tout de même être conçue avec soin.
Pour une équipe qui entretient une application existante, il est rarement nécessaire de convertir d’un coup les stores déjà fonctionnels. Il est plus utile d’évaluer chaque nouvel état selon sa portée, ses consommateurs et son cycle de vie. Les outils coexistent : le bon modèle est celui qui rend les dépendances compréhensibles et protège les données au bon niveau.
Organiser un état partagé fiable et éviter les erreurs courantes
Dans l’exemple de la boutique, un store de panier peut centraliser la liste des articles, tandis que le total est calculé à partir de cette liste. L’en-tête lit le nombre d’articles, la page panier affiche les détails et un bouton ajoute un produit. Cette organisation donne une source de vérité commune, mais elle ne dispense pas de définir où les règles de modification sont appliquées. Une fonction d’ajout peut vérifier si un article existe déjà avant d’augmenter sa quantité.
La première erreur fréquente consiste à créer un store pour chaque donnée, même lorsque celle-ci ne quitte jamais un composant. Cette dispersion ajoute des imports, rend les dépendances plus difficiles à suivre et peut faire paraître l’application plus globale qu’elle ne l’est. À l’inverse, conserver une donnée partagée dans un composant isolé oblige parfois à synchroniser plusieurs copies. Le critère utile est concret : plusieurs composants ont-ils besoin de lire ou modifier la même valeur au même moment ?
Une deuxième erreur concerne l’utilisation de get pour alimenter une interface. Cette fonction permet de lire ponctuellement une valeur, mais une lecture ponctuelle ne crée pas à elle seule une réaction aux changements futurs. Pour un affichage réactif dans un composant, le préfixe $ est généralement plus adapté. La souscription directe devient pertinente lorsqu’une opération doit se déclencher à chaque changement en dehors du rendu, à condition de prévoir la désinscription quand elle n’est plus nécessaire.
Une troisième source de confusion est le mélange entre données d’origine et données calculées. Si le panier conserve à la fois la liste des produits et un total modifié séparément à chaque action, une opération oubliée peut produire un montant erroné. Un store derived ou un calcul réactif basé sur la liste réduit ce risque. Pour les règles métier sensibles, comme les prix ou les remises, le calcul doit néanmoins être vérifié selon les besoins de l’application, notamment lorsqu’une source serveur fait autorité.
Lorsqu’un store readable utilise une minuterie ou une connexion, son démarrage et son nettoyage doivent être conçus ensemble. Une ressource qui reste active après la disparition de tous ses consommateurs gaspille des ressources et peut produire des mises à jour inutiles. De même, les souscriptions manuelles doivent avoir une durée de vie identifiable, plutôt que d’être créées sans suivi au fil des interactions.
Une démarche de vérification simple aide à garder la gestion d’état maîtrisable :
- Identifier les consommateurs : noter quels composants lisent la donnée et lesquels la modifient.
- Choisir la portée : préférer les props pour un échange local, le contexte pour des descendants, et un module ou un store pour un partage plus large selon le besoin.
- Séparer source et calcul : conserver les valeurs de référence et dériver les résultats qui peuvent être recalculés.
- Prévoir le cycle de vie : nettoyer les tâches autonomes et les abonnements lorsqu’ils ne sont plus utiles.
- Contrôler le rendu serveur : ne pas exposer des données propres à une requête dans un état de module partagé.
Cette méthode fonctionne aussi bien pour un petit compteur que pour une interface plus riche. En procédant ainsi, une équipe peut faire évoluer une application sans transformer chaque échange entre composants en mécanisme global. Un état partagé bien conçu possède une source identifiable, une portée maîtrisée et des règles de mise à jour prévisibles.
Questions fréquentes sur les stores Svelte
{« @context »: »https://schema.org », »@type »: »FAQPage », »mainEntity »:[{« @type »: »Question », »name »: »Les stores sont-ils toujours utiles avec Svelte 5 ? », »acceptedAnswer »:{« @type »: »Answer », »text »: »Oui. Svelte 5 offre aussi les runes, le contexte et les props, mais les stores restent pratiques pour les abonnements explicites, les valeurs autonomes avec cycle de vie et les projets ou bibliothu00e8ques qui les utilisent du00e9ju00e0. »}},{« @type »: »Question », »name »: »Quelle est la diffu00e9rence entre writable et readable ? », »acceptedAnswer »:{« @type »: »Answer », »text »: »Un store writable expose des mu00e9thodes pour modifier sa valeur, notamment set et update. Un readable permet de lire une valeur produite par une logique interne, sans modification directe depuis ses consommateurs. »}},{« @type »: »Question », »name »: »Pourquoi utiliser le pru00e9fixe $ devant un store ? », »acceptedAnswer »:{« @type »: »Answer », »text »: »Dans un composant Svelte, le pru00e9fixe $ permet de lire ru00e9activement la valeur du store et de mettre u00e0 jour lu2019affichage lorsquu2019elle change. Avec un writable, il peut aussi servir u00e0 modifier la valeur dans le composant. »}},{« @type »: »Question », »name »: »Un store de module convient-il aux donnu00e9es utilisateur dans SvelteKit ? », »acceptedAnswer »:{« @type »: »Answer », »text »: »Pas pour des donnu00e9es personnelles partagu00e9es cu00f4tu00e9 serveur : un module peut u00eatre commun u00e0 plusieurs requu00eates. Le contexte ou les props sont pru00e9fu00e9rables pour isoler lu2019u00e9tat propre u00e0 une requu00eate ou u00e0 un utilisateur. »}}]}Les stores sont-ils toujours utiles avec Svelte 5 ?
Oui. Svelte 5 offre aussi les runes, le contexte et les props, mais les stores restent pratiques pour les abonnements explicites, les valeurs autonomes avec cycle de vie et les projets ou bibliothèques qui les utilisent déjà.
Quelle est la différence entre writable et readable ?
Un store writable expose des méthodes pour modifier sa valeur, notamment set et update. Un readable permet de lire une valeur produite par une logique interne, sans modification directe depuis ses consommateurs.
Pourquoi utiliser le préfixe $ devant un store ?
Dans un composant Svelte, le préfixe $ permet de lire réactivement la valeur du store et de mettre à jour l’affichage lorsqu’elle change. Avec un writable, il peut aussi servir à modifier la valeur dans le composant.
Un store de module convient-il aux données utilisateur dans SvelteKit ?
Pas pour des données personnelles partagées côté serveur : un module peut être commun à plusieurs requêtes. Le contexte ou les props sont préférables pour isoler l’état propre à une requête ou à un utilisateur.






