0Pricing
TypeScript Academy · Leçon

Schémas zod/valibot et inférence

Validez les données non fiables avec des schémas ; déduisez directement les types TS à partir des validateurs ; comparez zod et valibot ; intégrez-les aux gestionnaires.

Schémas zod/valibot et inférence est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 2. 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 2 leçons au total.

Introduction

Objectif : traiter les entrées externes comme inconnues, les valider avec un schéma et inférer les types TS à partir de ce schéma. Vous utiliserez zod, découvrirez la syntaxe de valibot et créerez une petite fonction utilitaire pour les gestionnaires.

  • Une source unique de vérité
  • safeParse contre parse
  • Réutilisation des types inférés

Inférence avec zod

Définissez un schéma une seule fois. type User = z.infer<typeof userSchema> reproduit exactement les règles de validation.

import { z } from "zod"

export const userSchema = z.object({
  id: z.string().uuid(),
  name: z.string().min(1),
  age: z.number().int().min(0).optional()
})

export type User = z.infer<typeof userSchema>

// User is kept in sync with runtime rules.

safeParse contre parse

safeParse fournit un résultat de réussite ou d’échec sans déclencher d’exception, ce qui est idéal pour les gestionnaires HTTP ; parse déclenche une exception lorsque l’entrée n’est pas valide.

import type { Request, Response } from "express"
import { userSchema, type User } from "./schema"

export function createUser(req: Request, res: Response<User | { error: string; issues?: unknown }>) {
  const r = userSchema.safeParse(req.body)
  if (!r.success) {
    return res.status(400).json({ error: "Invalid body", issues: r.error.format() })
  }
  const user = r.data
  return res.status(201).json(user)
}

// parse() throws; safeParse() returns a discriminated union

Inférence avec valibot

valibot propose un validateur compact avec Infer<typeof schema>. Choisissez une bibliothèque et standardisez son utilisation dans toute l’équipe.

import { object, string, number, optional, minLength, uuid, minValue } from "valibot"
import type { Infer } from "valibot"

export const VUser = object({
  id: string([uuid()]),
  name: string([minLength(1)]),
  age: optional(number([minValue(0)]))
})

export type VUserT = Infer<typeof VUser>

// Similar idea: one schema, inferred type.

Fonction utilitaire de validation

Enveloppez l’analyse dans une petite fonction utilitaire afin que les gestionnaires reçoivent une structure simple { ok,data } ou { ok:false,issues }.

import { ZodTypeAny } from "zod"

export function validate<T extends ZodTypeAny, Out = unknown>(schema: T, value: unknown, onError?: (issues: unknown) => never | void): { ok: true; data: Out } | { ok: false; issues: unknown } {
  const r = schema.safeParse(value)
  if (!r.success) {
    const issues = r.error.format()
    if (onError) onError(issues as unknown as never)
    return { ok: false, issues }
  }
  return { ok: true, data: r.data as unknown as Out }
}

Conseils

Conseils :

  • Gardez les schémas près de la frontière (HTTP, CLI, entrées-sorties de la base de données).
  • Inférez les types et exportez-les — évitez les doublons écrits à la main.
  • Renvoyez 400 avec les détails des problèmes ; ne faites jamais confiance aux entrées du client.

Vérification de l’avantage de l’inférence

Vérification rapide : pourquoi inférer les types à partir des schémas ?

Récapitulatif

Récapitulatif : validez les entrées inconnues avec zod/valibot, utilisez safeParse et inférez les types afin d’aligner l’exécution et la compilation.

Questions Fréquemment Posées

La leçon « Schémas zod/valibot et inférence » est-elle gratuite ?

Oui — le texte complet de « Schémas zod/valibot et inférence » 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 2 leçons au total.

Qu'est-ce que j'apprendrai dans « Schémas zod/valibot et inférence » ?

Validez les données non fiables avec des schémas ; déduisez directement les types TS à partir des validateurs ; comparez zod et valibot ; intégrez-les aux gestionnaires. 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 1 sur 2.

Combien de temps prend la leçon « Schémas zod/valibot et inférence » ?

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. Schémas zod/valibot et inférence
  2. Analyse défensive et enveloppes d’erreur
← Retour à TypeScript Academy