Formations — 1 037 leçons en français

Accueil › Vue.js › Les composables

Les composables — entretien Vue.js

15 questions posées en entretien sur 10 sujets, avec la bonne réponse et son explication.

Définition

Qu'est-ce qu'un composable en Vue 3 ?

  1. Une fonction qui encapsule une logique avec état réactif, appelée pendant la mise en place d'un composant ✓
  2. Un composant sans template, enregistré globalement
  3. Une option de l'Options API qui remplace les mixins
  4. Un fichier exporté par défaut depuis le dossier composables

Pourquoi : Deux mots font la réponse complète : « état réactif » et « mise en place ». Une fonction qui formate une date n'est pas un composable, c'est un utilitaire : elle ne crée pas de ref et s'appelle n'importe où. Un composable, lui, déclare des ref et pose parfois des crochets de cycle de vie, ce qui impose l'endroit de l'appel.

Niveau junior

Convention

Que signifie le préfixe « use » devant un composable ?

  1. Une convention de nommage qui signale une fonction à état réactif ✓
  2. Une obligation du compilateur de templates, sans laquelle la fonction échoue
  3. Une directive qui enregistre la fonction auprès de l'application
  4. Un marqueur lu par Vite pour appliquer un traitement particulier

Pourquoi : Renommer « useSouris » en « souris » ne casse rien à l'exécution : ni Vue ni Vite ne lisent ce préfixe. Il sert au lecteur et aux règles de lint, en signalant qu'un appel crée de l'état réactif et doit donc rester au niveau supérieur de la mise en place. Croire que c'est une règle technique conduit à préfixer « use » de simples utilitaires.

Niveau junior

Valeur de retour

Que doit renvoyer un composable pour rester réactif après déstructuration ?

  1. Un objet plat dont les propriétés sont des ref, des computed et des fonctions ✓
  2. Un objet reactive contenant toutes les valeurs
  3. Un objet dont les propriétés sont les valeurs lues par « .value »
  4. Un tableau, pour permettre le renommage libre

Pourquoi : L'appelant écrit presque toujours une déstructuration. Renvoyer « .value » copie la valeur à l'instant de l'appel : l'affichage montre l'état initial et ne bouge plus, sans aucun avertissement. Renvoyer un objet reactive fonctionne, mais interdit la déstructuration à l'appelant, ce qui va à l'encontre de l'usage attendu.

Niveau junior

toRefs

À quoi sert « toRefs » à la sortie d'un composable ?

  1. À transformer chaque propriété d'un objet réactif en ref, pour que la déstructuration conserve le lien ✓
  2. À rendre un objet ordinaire réactif en profondeur
  3. À convertir des ref en valeurs nues avant de les renvoyer
  4. À geler un objet réactif en lecture seule

Pourquoi : Étaler un objet reactive avec les trois points copie ses primitives : le lien est perdu. « toRefs » crée pour chaque clé une ref branchée sur le proxy, si bien que la déstructuration reste vivante. À ne pas confondre avec « reactive », qui crée la réactivité, ni avec « readonly », qui interdit l'écriture.

Niveau junior

Portée de l'état

Deux composants appellent le même composable. Que partagent-ils par défaut ?

  1. Le code uniquement : chaque appel crée ses propres ref ✓
  2. Les ref, mises en cache par Vue au premier appel
  3. Les ref seulement si les deux composants sont montés en même temps
  4. Rien, chacun reçoit une copie complète du module

Pourquoi : Un composable est une fonction ordinaire : son corps s'exécute entièrement à chaque appel, et ses ref sont des variables locales neuves. C'est le comportement voulu — deux listes paginées veulent chacune leur page. L'erreur fréquente consiste à y voir un singleton et à compter dessus pour faire communiquer deux composants.

Niveau junior

Un composable charge des données dans « onMounted ». Trois composants l'appellent. Que se passe-t-il ?

  1. Trois requêtes partent et trois copies des données coexistent ✓
  2. Une seule requête part, Vue déduplique les appels identiques
  3. Une erreur est levée au second appel
  4. Les trois composants partagent la liste, car onMounted n'est exécuté qu'une fois

Pourquoi : Chaque appel exécute le corps du composable, donc crée ses ref et enregistre son propre « onMounted ». Vue ne déduplique rien : il ignore que les trois appels visent la même ressource. Pour une requête unique, il faut rendre le partage explicite, par un cache au niveau du module ou par un store.

Niveau confirme

Composable ou store

Quel critère fait choisir un store Pinia plutôt qu'un composable à état local ?

  1. Plusieurs composants sans lien hiérarchique doivent lire et écrire le même état ✓
  2. La logique dépasse une certaine taille et mérite son propre fichier
  3. Un appel réseau est nécessaire au chargement
  4. Il faut dériver des valeurs avec computed

Pourquoi : Le critère est le partage, pas la taille ni la nature de la logique. Un composable peut parfaitement contenir une requête, des computed et cent lignes tout en restant local. Dès que l'utilisateur connecté ou un panier doivent être vus identiquement par des composants éloignés, l'état doit exister en un exemplaire, et c'est le rôle du store.

Niveau confirme

État de module

Où déclarer une ref pour qu'elle soit partagée par tous les appels d'un composable ?

  1. Au niveau du module, hors du corps de la fonction ✓
  2. Dans le corps de la fonction, en la déclarant avec shallowRef
  3. Dans le corps de la fonction, précédée du mot-clé export
  4. Dans un onMounted, pour garantir une seule exécution

Pourquoi : Un module ES est évalué une fois : ce qu'il déclare à son niveau supérieur existe en un exemplaire, quel que soit le nombre d'imports. Le mettre dans le corps le recrée à chaque appel. « shallowRef » ne change rien à la durée de vie : il ne concerne que la profondeur du suivi.

Niveau confirme

Qu'affiche ce code, les deux appels venant de deux composants distincts ?

// compteur.js
import { ref } from 'vue'
const total = ref(0)

export function useTotal() {
  const local = ref(0)
  function plus() { total.value++; local.value++ }
  return { total, local, plus }
}

// usage
const a = useTotal()
const b = useTotal()
a.plus(); a.plus(); b.plus()
console.log(a.total.value, a.local.value, b.local.value)
  1. 3 2 1 ✓
  2. 3 3 3
  3. 2 2 1
  4. 1 2 1

Pourquoi : « total » est déclaré au niveau du module : une seule ref pour tous les appels, donc trois incréments donnent trois. « local » est dans le corps, donc recréé à chaque appel. Le même fichier mêle ici un état partagé et un état par instance, et seule la position de la déclaration les distingue.

Niveau confirme

Un indicateur « chargement » est déclaré au niveau du module. L'utilisateur quitte la page pendant la requête. Que voit-il en revenant ?

  1. L'indicateur est encore à vrai, car l'état de module survit au démontage ✓
  2. L'indicateur est remis à faux, car le composant a été démonté
  3. Une erreur, car l'état a été détruit avec le composant
  4. L'indicateur est remis à faux au changement de route par le routeur

Pourquoi : L'état de module ne dépend d'aucun composant : il vit tant que le module est chargé, donc tant que l'onglet est ouvert. Ni le démontage ni le routeur ne le réinitialisent. C'est l'argument du motif pour un thème, et son défaut pour un indicateur de chargement ou un message d'erreur, qui doivent repartir à zéro.

Niveau confirme

Arguments réactifs

Quelles formes d'argument « toValue » sait-il résoudre ?

  1. Une valeur nue, une ref, et une fonction d'accès sans argument ✓
  2. Une ref et un objet reactive uniquement
  3. Une ref uniquement, comme unref
  4. Toute valeur, y compris une promesse, qu'il attend avant de renvoyer

Pourquoi : « toValue » renvoie une valeur nue inchangée, déballe une ref, et appelle une fonction. C'est ce qui permet de typer un paramètre « MaybeRefOrGetter ». La confusion fréquente est avec « unref », qui connaît la ref mais pas la fonction d'accès et la renverrait telle quelle. Rien dans Vue n'attend une promesse à cet endroit.

Niveau confirme

Pourquoi passer « props.id » directement à un composable ne suffit-il généralement pas ?

  1. Le composable n'est appelé qu'une fois : il reçoit la valeur de cet instant et ne verra pas les suivantes ✓
  2. Les props sont en lecture seule et ne peuvent pas être passées en argument
  3. Vue interdit de lire une prop en dehors du template
  4. La valeur est toujours undefined pendant la mise en place

Pourquoi : La mise en place s'exécute une seule fois par instance de composant. Lire « props.id » dans l'appel produit un nombre ou une chaîne, et le lien avec la prop est rompu. Passer « () => props.id » ou une ref donne au composable une source relisable, exactement comme pour la source d'un watch. Les props ne sont pas en cause : elles sont bien lisibles dans le script.

Niveau confirme

Quel est le défaut de ce composable ?

export function useDouble(source) {
  const v = toValue(source)
  const double = computed(() => v * 2)
  return { double }
}
  1. « toValue » est appelé hors de l'effet, donc la dépendance n'est jamais enregistrée ✓
  2. « computed » ne peut pas multiplier une valeur déballée
  3. « toValue » doit toujours recevoir une ref, pas une fonction
  4. Il manque un « .value » sur « v » dans le computed

Pourquoi : La lecture a lieu une seule fois, pendant la mise en place : « v » est un nombre figé et le computed n'a aucune dépendance réactive, donc il ne se recalcule jamais. Le code paraît correct parce qu'il utilise « toValue ». La forme juste est « computed(() => toValue(source) * 2) », qui relit la source à chaque évaluation.

Niveau senior

Rendu côté serveur

Pourquoi un état déclaré au niveau du module pose-t-il problème en rendu côté serveur ?

  1. Le module est évalué une fois dans le processus, donc l'état est partagé entre les requêtes de tous les utilisateurs ✓
  2. Vue refuse de créer des ref hors d'un composant côté serveur
  3. L'état de module n'est pas sérialisé dans le HTML envoyé au navigateur
  4. Le serveur recharge le module à chaque requête, ce qui dégrade les temps de réponse

Pourquoi : Dans un navigateur, un module vit le temps d'un onglet, donc d'un seul utilisateur. Dans un processus Node qui rend des pages, il est chargé une fois et sert toutes les requêtes : ce qu'une requête écrit reste lisible par la suivante. C'est précisément pour cela qu'un store Pinia construit son état par une fonction, appelée une fois par instance d'application.

Niveau senior

Cycle de vie

Pourquoi un composable ne doit-il pas être appelé après un « await » dans la mise en place ?

  1. L'instance courante n'est plus active après le premier await, donc les crochets de cycle de vie ne s'attachent à rien ✓
  2. Les fonctions asynchrones ne peuvent pas créer de ref
  3. Vue lève une exception bloquante au second await
  4. Le composable renverrait une promesse au lieu d'un objet

Pourquoi : Vue retient l'instance courante pendant l'exécution synchrone de la mise en place, et c'est elle qui reçoit « onMounted » ou « onUnmounted ». Après un await, cette instance n'est plus celle en cours : les crochets enregistrés ensuite sont perdus, et Vue avertit en développement. La correction est d'appeler le composable avant, puis d'attendre à l'intérieur.

Niveau senior

S'entraîner sur ces questions, chronométré →