0Pricing
TypeScript Academy · Leçon

Composer et affiner des schémas

Créer des schémas complexes avec refine, transform et des unions.

Composer et affiner des schémas est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 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 se composent

Les schémas Zod sont des éléments fondamentaux combinables. Vous pouvez les affiner, les transformer, les étendre et les associer pour modéliser des règles de validation complexes.

import { z } from "zod";
const base = z.object({ name: z.string() });
// We will add rules and combine schemas from here.

Règles personnalisées avec refine

.refine ajoute un prédicat de validation personnalisé accompagné d’un message d’erreur, pour les règles que Zod ne fournit pas intégrées.

import { z } from "zod";
const password = z.string().refine(
  (s) => s.length >= 8,
  { message: "Must be at least 8 characters" }
);
// password.parse("short") throws with that message.

Affiner entre plusieurs champs

Appliquez .refine à un objet pour valider les relations entre ses champs, par exemple une confirmation de password identique.

import { z } from "zod";
const form = z.object({
  password: z.string(),
  confirm: z.string()
}).refine((d) => d.password === d.confirm, {
  message: "Passwords must match"
});
// Validates both fields together.

Transformer des valeurs

.transform convertit une valeur validée en une autre forme, après la réussite de la validation.

import { z } from "zod";
const trimmed = z.string().transform((s) => s.trim());
const result = trimmed.parse("  hi  "); // "hi"

Champs facultatifs

.optional() autorise l’absence d’un champ, ce qui se reflète à la fois dans la validation et dans le type inféré.

import { z } from "zod";
const schema = z.object({
  name: z.string(),
  bio: z.string().optional()
});
// bio may be omitted.

Valeurs par défaut

.default fournit une valeur lorsque les données d’entrée sont absentes, de sorte que le résultat analysé possède toujours ce champ.

import { z } from "zod";
const schema = z.object({
  retries: z.number().default(3)
});
const r = schema.parse({}); // { retries: 3 }

Schémas d’union

z.union accepte une valeur correspondant à l’un de plusieurs schémas, l’équivalent Zod d’une union TypeScript.

import { z } from "zod";
const id = z.union([z.string(), z.number()]);
// id.parse("abc") and id.parse(123) both succeed.

Unions discriminées dans Zod

z.discriminatedUnion valide efficacement les unions balisées en choisissant une branche selon un champ discriminant.

import { z } from "zod";
const shape = z.discriminatedUnion("kind", [
  z.object({ kind: z.literal("circle"), radius: z.number() }),
  z.object({ kind: z.literal("square"), side: z.number() })
]);
// Picks the right member by kind.

Fusionner avec extend

.extend ajoute des champs à un schema d’objet existant, ce qui vous permet de construire de grands schémas à partir de schémas plus petits.

import { z } from "zod";
const base = z.object({ id: z.number() });
const user = base.extend({ name: z.string() });
// user validates { id: number; name: string }

Combiner des schémas d’objets

Vous pouvez également fusionner deux schémas d’objets avec .merge afin de réunir tous leurs champs dans un seul schema.

import { z } from "zod";
const a = z.object({ x: z.number() });
const b = z.object({ y: z.string() });
const combined = a.merge(b);
// combined validates { x: number; y: string }

Tout enchaîner

Les affinements, transformations, valeurs par défaut et extensions s’enchaînent naturellement pour exprimer une validation riche dans un schema unique et lisible.

import { z } from "zod";
const signup = z.object({
  email: z.string().refine(s => s.includes("@"), { message: "Invalid email" }),
  age: z.number().default(18)
}).extend({
  newsletter: z.boolean().optional()
});
// One schema, many rules.

Vérification rapide : composer des schémas

Vérifiez votre compréhension de la composition et de l’affinement des schémas.

Récapitulatif : composer et affiner des schémas

Vous avez appris à ajouter des règles personnalisées avec .refine, à remodeler les valeurs avec .transform, à gérer les données absentes avec .optional et .default, à combiner des alternatives avec z.union et à développer les schémas avec .extend et .merge.

import { z } from "zod";
const schema = z.object({ name: z.string() })
  .extend({ age: z.number().default(0) })
  .refine(d => d.name.length > 0, { message: "Name required" });
// Composed validation in one place.

Questions Fréquemment Posées

La leçon « Composer et affiner des schémas » est-elle gratuite ?

Oui — le texte complet de « Composer et affiner des 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 « Composer et affiner des schémas » ?

Créer des schémas complexes avec refine, transform et des unions. 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 4 sur 4.

Combien de temps prend la leçon « Composer et affiner des 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

  1. Principes des schémas Zod
  2. Inférer des types à partir de schémas
  3. parse ou safeParse
  4. Composer et affiner des schémas
← Retour à TypeScript Academy