Formations — 1 037 leçons en français

Accueil › Vue.js › Vue et TypeScript

Vue et TypeScript — entretien Vue.js

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

Déclaration des props

Comment déclare-t-on des props typées dans « script setup » ?

  1. En passant un argument de type à « defineProps », par exemple « defineProps<{ titre: string }>() » ✓
  2. En annotant la variable qui reçoit le résultat de « defineProps »
  3. En déclarant une interface nommée « Props » dans le fichier, détectée automatiquement
  4. En ajoutant une option « types » au bloc script

Pourquoi : Le compilateur de fichier mono-composant lit l'argument de type et en déduit la déclaration d'exécution que Vue utilisera. Annoter la variable de réception ne produirait rien à l'exécution : Vue ne verrait aucune prop déclarée et tout arriverait en attribut de retombée. Le nom de l'interface n'a aucune importance, seul l'argument de type compte.

Niveau junior

Dans une déclaration par type, comment rend-on une prop facultative ?

  1. Avec un point d'interrogation après son nom ✓
  2. En ajoutant « required: false » à côté du type
  3. En la déclarant avec le type « undefined »
  4. En l'enveloppant dans « Partial »

Pourquoi : Le caractère « ? » du type est traduit en « required: false » dans la déclaration d'exécution générée. Écrire « required » à la main est impossible : la déclaration par type et la déclaration d'exécution s'excluent. Envelopper l'ensemble dans « Partial » rendrait toutes les props facultatives d'un coup, ce qui est rarement l'intention.

Niveau junior

Émissions

Que vérifie « defineEmits » dans sa forme de type, qu'il ne vérifie pas dans sa forme en tableau ?

  1. La charge utile de chaque événement : son nombre d'arguments et leurs types ✓
  2. Que le parent écoute bien l'événement
  3. Que l'événement est émis au moins une fois
  4. Que le nom de l'événement respecte la casse kebab

Pourquoi : La forme en tableau ne déclare que des noms : un appel sans argument passe sans rien signaler. La forme de type décrit la liste d'arguments comme des paramètres de fonction, et le parent reçoit un gestionnaire déjà typé. Rien ne peut en revanche vérifier qu'un parent écoute : c'est une décision prise à l'usage, pas à la déclaration.

Niveau junior

Typage de l'état

Pourquoi « const produits = ref([]) » pose-t-il problème en TypeScript ?

  1. Le type déduit est celui d'un tableau vide, et affecter un vrai tableau est ensuite refusé ✓
  2. « ref » refuse un tableau comme valeur initiale
  3. Le tableau perd sa réactivité en profondeur
  4. La variable devient une « ref » superficielle

Pourquoi : Un tableau littéralement vide ne porte aucune information sur ce qu'il contiendra, et l'inférence produit un type d'éléments vide. Il faut écrire l'argument de type : « ref<Produit[]>([]) ». Le même problème se pose avec « null » comme valeur initiale, où l'on écrit « ref<Produit | null>(null) ».

Niveau junior

Valeurs par défaut

Pourquoi une valeur par défaut de type tableau s'écrit-elle « () => [] » dans « withDefaults » ?

  1. Parce que la valeur fait partie de la déclaration d'exécution, partagée par toutes les instances du composant ✓
  2. Parce que « withDefaults » n'accepte que des fonctions
  3. Parce que Vue appelle la fabrique à chaque rendu pour garder la réactivité
  4. Parce qu'un tableau littéral casserait l'inférence du type de la prop

Pourquoi : La déclaration d'exécution est créée une fois pour le composant. Un tableau littéral y serait le même objet pour toutes les instances, et une modification faite dans l'une se verrait dans les autres. La fabrique produit une valeur neuve par instance. Avec la déstructuration réactive, l'expression est évaluée à chaque mise en place et la question disparaît.

Niveau confirme

Déstructuration des props

Après « const { quantite } = defineProps<Props>() », comment surveille-t-on cette prop ?

  1. Avec « watch(() => quantite, ...) » ✓
  2. Avec « watch(quantite, ...) »
  3. Avec « watch(props.quantite, ...) »
  4. Avec « watchEffect » uniquement, « watch » ne fonctionnant pas sur une prop déstructurée

Pourquoi : Depuis Vue 3.5, la déstructuration des props reste réactive parce que le compilateur réécrit chaque accès à la variable. Mais la variable n'est pas une « ref » : la passer directement à « watch » transmet un nombre, et rien n'est observé. L'accesseur rétablit la lecture au bon moment. « watchEffect » fonctionne aussi, puisqu'il lit la variable dans son corps.

Niveau confirme

Composants génériques

Que permet l'attribut « generic » sur un bloc « script setup » ?

  1. Déclarer un paramètre de type pour le composant, déduit des props à chaque utilisation ✓
  2. Autoriser le composant à recevoir n'importe quelle prop sans la déclarer
  3. Rendre le composant utilisable sans l'importer
  4. Générer automatiquement une déclaration d'exécution pour les props

Pourquoi : Disponible depuis Vue 3.3, cet attribut exige « lang="ts" » et accepte une liste de paramètres de type, contraintes comprises. Il exprime le lien entre plusieurs props : un tableau d'éléments et la sélection qui en vient doivent partager le même type. Sans lui, on retomberait sur un tableau de valeurs inconnues, et tout contrôle disparaîtrait.

Niveau confirme

Pourquoi contraindre un paramètre de type avec « extends » ?

  1. Pour pouvoir lire à l'intérieur du composant les propriétés garanties par la contrainte ✓
  2. Parce qu'un paramètre de type sans contrainte est refusé par le compilateur
  3. Pour que le type soit visible depuis le parent
  4. Pour permettre la déduction du type à partir d'un tableau vide

Pourquoi : Un paramètre libre n'a aucune propriété connue : « element.id » est refusé tant que rien ne garantit que « id » existe. La contrainte fait cette garantie. Elle reste inutile quand le composant ne fait que transporter la valeur sans la lire, et la réponse à une erreur d'accès est toujours la contrainte, jamais une conversion vers un type quelconque.

Niveau confirme

Entrées d'un composable

Quelle différence entre « toValue » et « unref » ?

  1. « toValue » appelle aussi une fonction passée en argument, « unref » la renvoie telle quelle ✓
  2. « toValue » déballe en profondeur, « unref » seulement à la racine
  3. « toValue » fonctionne hors d'un composant, « unref » non
  4. « toValue » crée une copie de la valeur, « unref » renvoie la référence d'origine

Pourquoi : « unref » ne connaît que deux cas : une « ref », qu'il déballe, et tout le reste, qu'il laisse passer — une fonction incluse, qui finit alors utilisée comme valeur. « toValue », introduit en Vue 3.3, ajoute le cas de l'accesseur. C'est ce qui permet d'accepter en entrée d'un composable une valeur, une « ref » ou un accesseur avec une seule signature.

Niveau confirme

Injection

Que renvoie « inject(cle) » quand « cle » est un « InjectionKey<Panier> » sans valeur par défaut ?

  1. « Panier | undefined » ✓
  2. « Panier », l'injection étant garantie par la clé typée
  3. « unknown »
  4. « Panier | null »

Pourquoi : Rien ne garantit statiquement qu'un fournisseur existe plus haut dans l'arbre : le type inclut donc l'absence. Fournir une valeur par défaut en second argument supprime cette union. L'autre réponse propre est de vérifier et de lever une erreur explicite, ce qui donne un message utile quand le composant est utilisé hors de son fournisseur.

Niveau confirme

Limites du template

Que produit ce template ?

<script setup lang="ts">
import { ref } from 'vue'
const groupe = { compteur: ref(2) }
</script>

<template>{{ groupe.compteur }}</template>
  1. L'objet « ref » lui-même, rendu en « [object Object] » ✓
  2. La valeur 2, grâce au déballage automatique
  3. Une erreur de compilation du template
  4. Une chaîne vide, le déballage échouant en silence

Pourquoi : Le déballage automatique s'applique aux liaisons du niveau supérieur de « script setup », pas à une « ref » rangée dans un objet ordinaire. Le type reste pourtant exact, donc l'analyse n'a rien à signaler : c'est un bug qu'aucun outil ne détecte. Il faut écrire « .value », ou faire du conteneur un objet réactif.

Niveau senior

Pinia

Pourquoi un getter Pinia qui en lit un autre par « this » exige-t-il un type de retour explicite ?

  1. Parce que l'inférence devient circulaire : le type du getter dépend de celui du store, qui dépend du sien ✓
  2. Parce que « this » n'est pas typé dans un store d'options
  3. Parce qu'un getter ne peut pas être une fonction fléchée
  4. Parce que Pinia évalue les getters dans un ordre indéterminé

Pourquoi : TypeScript doit connaître le type du store pour typer « this », et le type du store contient celui de ce getter : la boucle est fermée. L'annotation la rompt en donnant un point fixe. L'interdiction de la fonction fléchée est une conséquence liée — une fléchée n'a pas de « this » propre — pas la cause de l'exigence.

Niveau senior

Frontières d'exécution

Que garantit « (await reponse.json()) as Produit[] » à l'exécution ?

  1. Rien : une conversion affirme un type sans le vérifier ✓
  2. Que les champs manquants seront « undefined » plutôt qu'absents
  3. Que Vue signalera un avertissement si la forme ne correspond pas
  4. Que les propriétés en trop seront retirées du résultat

Pourquoi : Les types disparaissent à la compilation : une conversion est une promesse faite au compilateur, pas un contrôle. Si le serveur change de contrat, le code compile toujours et casse plus tard, loin de l'appel. La réponse est une validation d'exécution à la frontière, après quoi le reste du code peut faire confiance à ses types.

Niveau senior

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