0Pricing
TypeScript Academy · Lektion

Schema-Validierung mit zod und Inferenz nach TS

Validieren Sie Requests mit zod, leiten Sie TypeScript-Typen aus Schemas ab und ergänzen Sie sichere Middleware und Fehlerbehandlung.

Schema-Validierung mit zod und Inferenz nach TS ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.

Einführung

Ziel: Validieren Sie eingehende Daten mit zod und halten Sie TypeScript-Typen mit z.infer synchron. Sie parsen sicher, senden hilfreiche Fehler und binden die Validierung in eine Middleware ein.

  • Definieren Sie Schemas einmalig.
  • Leiten Sie TS-Typen ab.
  • safeParse + 400-Fehler

Schema und infer

Modellieren Sie die Daten einmalig mit zod. Der abgeleitete Typ type User = z.infer<typeof userSchema> bildet die Validierung exakt ab.

import { z } from "zod"

export const userSchema = z.object({
  id: z.string().regex(/^u_[a-z0-9]+$/),
  name: z.string().min(1),
  age: z.number().int().nonnegative().optional()
})

export type User = z.infer<typeof userSchema>

// Reuse `User` across handlers, services, and tests

safeParse im Handler

Verwenden Sie safeParse, um Ausnahmen zu vermeiden, und geben Sie 400 mit formatierten Problemen zurück. Der Response-Typ bildet sowohl die Erfolgs- als auch die Fehlerform ab.

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

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

Middleware-Hilfe

Erstellen Sie eine wiederverwendbare Middleware. Sie parst den Body und hängt entweder die typisierten Daten an oder gibt eine 400-Antwort mit Details zurück.

import { z } from "zod"
import { Request, Response, NextFunction } from "express"

export function validateBody<T extends z.ZodTypeAny>(schema: T) {
  return (req: Request, res: Response, next: NextFunction) => {
    const r = schema.safeParse(req.body)
    if (!r.success) {
      return res.status(400).json({ error: "Invalid body", issues: r.error.format() })
    }
    req.body = r.data
    next()
  }
}

Coercion & refine

Verwenden Sie z.coerce, um Zahlen als Strings zu akzeptieren, z.enum für bekannte Werte und .refine für Regeln über mehrere Felder hinweg.

import { z } from "zod"

const signupSchema = z.object({
  email: z.string().email(),
  age: z.coerce.number().int().gte(13),
  role: z.enum(["user", "admin"]).default("user")
}).refine(v => v.role !== "admin" || v.age >= 18, { message: "admin must be adult" })

export type Signup = z.infer<typeof signupSchema>

// Coercion allows numbers in strings; refine adds cross-field rules

Fehler-Tipps

Fehler-Tipps:

  • Verwenden Sie am Rand der Anwendung immer safeParse.
  • Bereiten Sie Fehler für Clients auf; vermeiden Sie das Durchsickern von Stacktraces.
  • Schränken Sie unknown auf ZodError ein, wenn Sie ausgelöste Parse-Fehler abfangen.

zod-Typinferenz prüfen

Kurze Prüfung: Wie halten Sie TS-Typen und zod-Schemas synchron?

Zusammenfassung

Zusammenfassung: Definieren Sie ein Schema, leiten Sie den TS-Typ ab, validieren Sie mit safeParse und binden Sie es in Middleware ein, um konsistente 400-Fehler zurückzugeben.

Häufig gestellte Fragen

Ist die Lektion „Schema-Validierung mit zod und Inferenz nach TS“ kostenlos?

Ja — der vollständige Text von „Schema-Validierung mit zod und Inferenz nach TS“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Schema-Validierung mit zod und Inferenz nach TS“?

Validieren Sie Requests mit zod, leiten Sie TypeScript-Typen aus Schemas ab und ergänzen Sie sichere Middleware und Fehlerbehandlung. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „Schema-Validierung mit zod und Inferenz nach TS“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Router-Handler, Request-/Response-Typisierung
  2. Schema-Validierung mit zod und Inferenz nach TS
  3. Fehler-Middleware und Result-Typen
← Zurück zu TypeScript Academy