TypeScript Academy · Leçon

Inférer des types à partir de schémas

Déduire directement des types statiques à partir de schémas Zod.

Leçon 2 sur 413 étapes

Inférer des types à partir de schémas est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Les schémas portent des informations de type

Un schema Zod connaît le type TypeScript qu’il valide. z.infer extrait ce type, de sorte que vous définissiez la forme once une seule fois.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
// User is { name: string; age: number }

L’utilitaire z.infer

z.infer<typeof schema> produit le type statique que le schema valide. Remarquez le typeof : vous transmettez la valeur du schema.

import { z } from "zod";
const tagSchema = z.array(z.string());
type Tags = z.infer<typeof tagSchema>; // string[]

Une source unique de vérité

Sans inférence, vous devriez gérer séparément un type et un schema, qui pourraient ensuite diverger. z.infer les maintient parfaitement synchronisés.

import { z } from "zod";
const schema = z.object({ id: z.number(), email: z.string() });
type Account = z.infer<typeof schema>;
// Change the schema, the type updates automatically.

Inférer des types imbriqués

L’inférence gère les objets et les tableaux imbriqués et produit le type TypeScript complet et imbriqué à partir d’un seul schema.

import { z } from "zod";
const postSchema = z.object({
  title: z.string(),
  author: z.object({ name: z.string() }),
  tags: z.array(z.string())
});
type Post = z.infer<typeof postSchema>;
// Post.author.name is string

Utiliser le type inféré

Utilisez le type inféré partout où vous utiliseriez un type écrit manuellement : paramètres de fonction, variables et types de retour.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
function greet(u: User): string {
  return "Hi " + u.name;
}

parse renvoie le type inféré

schema.parse renvoie une valeur déjà typée comme le type inféré ; le code qui suit est donc entièrement typé.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
const raw: unknown = { name: "Ada", age: 36 };
const user: User = userSchema.parse(raw); // typed and validated

Optionnel et pouvant être nul dans le type

Les modificateurs d’un schema se répercutent dans le type inféré. Un champ .optional() devient facultatif en TypeScript.

import { z } from "zod";
const schema = z.object({
  name: z.string(),
  nickname: z.string().optional()
});
type P = z.infer<typeof schema>;
// P is { name: string; nickname?: string }

Inférer à partir de tableaux d’objets

Combinez z.array et z.object : le type inféré est alors un tableau du type de l’objet.

import { z } from "zod";
const usersSchema = z.array(z.object({ id: z.number() }));
type Users = z.infer<typeof usersSchema>;
// Users is { id: number }[]

Pourquoi l’opérateur de type est nécessaire

Le schema est une valeur ; vous faites donc référence à son type avec typeof schema avant de le transmettre à z.infer.

import { z } from "zod";
const s = z.string();
type S = z.infer<typeof s>; // string
// z.infer<s> would be wrong: s is a value, not a type.

Inférence entre les limites des modules

Exportez à la fois le schema et son type inféré afin que les autres modules puissent valider et utiliser la même shape de manière cohérente.

import { z } from "zod";
export const userSchema = z.object({ name: z.string() });
export type User = z.infer<typeof userSchema>;
// Consumers import both the runtime schema and the type.

Une définition, deux univers

Le schema sert à la validation à l’exécution ; z.infer sert au typage à la compilation. Une seule déclaration permet les deux et élimine la duplication.

import { z } from "zod";
const configSchema = z.object({ port: z.number(), host: z.string() });
type Config = z.infer<typeof configSchema>;
// Validate at runtime, type at compile time, no drift.

Vérification rapide : inférer des types

Vérifiez votre compréhension de l’inférence des types à partir des schémas.

Réponds-y dans la leçon interactive

Récapitulatif : inférer des types à partir des schémas

Vous avez appris que z.infer<typeof schema> dérive un type TypeScript à partir d’un schema Zod, offrant une source unique de vérité pour la validation et les types, y compris pour les shapes imbriquées, facultatives et en tableaux.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
// User stays in sync with the schema automatically.

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 « Inférer des types à partir de schémas » est-elle gratuite ?

Oui — le texte complet de « Inférer des types à partir de schémas » 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 « Inférer des types à partir de schémas » ?

Déduire directement des types statiques à partir de schémas Zod. 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 2 sur 4.

Combien de temps prend la leçon « Inférer des types à partir de schémas » ?

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