TypeScript Academy · Leçon

reflect-metadata et types de conception

Capturer les types des paramètres et des propriétés à l’exécution.

Leçon 3 sur 413 étapes

reflect-metadata et types de conception est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

reflect-metadata et types de conception

Avant l’existence de métadonnées normalisées, TypeScript pouvait émettre à l’exécution des informations de type disponibles à la conception grâce à la bibliothèque reflect-metadata et à l’option du compilateur emitDecoratorMetadata. Cette leçon présente ce mécanisme plus ancien, mais encore largement utilisé.

Activation de la fonctionnalité

Deux éléments sont nécessaires : activez les options du compilateur et importez la bibliothèque une fois au point d’entrée du programme.

// tsconfig.json
// {
//   "compilerOptions": {
//     "experimentalDecorators": true,
//     "emitDecoratorMetadata": true
//   }
// }

import "reflect-metadata";

Ce qui est émis

Avec emitDecoratorMetadata, le compilateur émet trois clés pour les membres décorés : design:type, design:paramtypes et design:returntype. Les valeurs sont les fonctions constructeur, par exemple String et Number.

Lecture de design:type

Pour une propriété décorée, Reflect.getMetadata("design:type", target, key) renvoie le constructeur correspondant au type de la propriété.

import "reflect-metadata";

function track(target: any, key: string) {
  const t = Reflect.getMetadata("design:type", target, key);
  console.log(key, "->", t.name); // e.g. "name -> String"
}

class Person {
  @track name!: string;
  @track age!: number;
}

Lecture de design:paramtypes

Sur un constructeur ou une méthode, design:paramtypes est un tableau des constructeurs correspondant aux types des paramètres, à la base de l’injection de dépendances.

function injectable(target: any) {
  const params = Reflect.getMetadata("design:paramtypes", target);
  console.log(params.map((p: any) => p.name)); // ["Database", "Logger"]
}

@injectable
class Service {
  constructor(private db: Database, private log: Logger) {}
}

Limites des types émis

Seuls les types simples représentables à l’exécution subsistent. Les interfaces, les unions et les types génériques deviennent Object, car ils ne possèdent aucun constructeur à l’exécution. Les types de conception sont approximatifs et ne représentent pas le type TS complet.

Métadonnées personnalisées avec Reflect

Vous pouvez également définir vos propres clés de métadonnées avec Reflect.defineMetadata, indépendamment des types de conception.

import "reflect-metadata";

function required(target: any, key: string) {
  Reflect.defineMetadata("required", true, target, key);
}

function isRequired(target: any, key: string) {
  return Reflect.getMetadata("required", target, key) === true;
}

Domaines d’utilisation

Ce mécanisme est au cœur de nombreux cadres établis (NestJS, TypeORM, class-validator). Ils lisent design:type et design:paramtypes pour relier les dépendances et valider les valeurs sans vous obliger à répéter les types.

reflect-metadata et métadonnées standard

La nouvelle API Symbol.metadata fait partie du langage et n’émet pas les types de conception. reflect-metadata fournit de manière unique des informations de type, mais reste lié au mode expérimental des décorateurs. Choisissez un seul modèle par projet.

L’ordre des imports est important

import "reflect-metadata" doit s’exécuter une seule fois, avant l’évaluation de toute classe décorée, car il modifie l’objet global Reflect en lui ajoutant les fonctions de métadonnées. Importez-le tout en haut de votre fichier d’entrée.

Pourquoi c’est important

L’émission des types de conception permet aux cadres de combler l’écart entre les types à la compilation et le comportement à l’exécution, ce qui rend possibles une injection de dépendances et une validation ergonomiques. Connaître ses limites (pas d’interfaces ni de types génériques) évite les résultats Object surprenants.

Vérification rapide

Vérifiez votre compréhension de reflect-metadata.

Réponds-y dans la leçon interactive

Récapitulatif

Avec experimentalDecorators et emitDecoratorMetadata, ainsi qu’un import "reflect-metadata" précoce, le compilateur émet design:type et design:paramtypes sous forme de constructeurs disponibles à l’exécution. Les cadres les lisent pour l’injection de dépendances et la validation, même si les interfaces, les unions et les types génériques deviennent Object.

Gratuit pour commencer

Apprends TypeScript avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 101
Leçons: 352

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « reflect-metadata et types de conception » est-elle gratuite ?

Oui — le texte complet de « reflect-metadata et types de conception » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « reflect-metadata et types de conception » ?

Capturer les types des paramètres et des propriétés à l’exécution. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « reflect-metadata et types de conception » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à TypeScript Academy