0Pricing
tRPC End-to-End Type Safe APIs · Lezione

Introduzione agli schemi Zod

Esplori Zod, una libreria TypeScript-first per la dichiarazione e la validazione degli schemi, e i suoi tipi di base.

Introduzione agli schemi Zod è una lezione tRPC End-to-End Type Safe APIs gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento tRPC End-to-End Type Safe APIs, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso tRPC End-to-End Type Safe APIs include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

What is Zod?

Welcome to Zod! It's a powerful, TypeScript-first validation library. Think of it as a guardian for your data.

Zod helps ensure that the data entering your application (from APIs, forms, etc.) matches the types you expect, even at runtime.

Why Use Zod? Type Safety!

TypeScript provides type safety during development, but what about data received from a server or user input? That data doesn't have TypeScript types.

Zod bridges this gap! It allows you to define a schema, validate runtime data against it, and automatically infer a TypeScript type from that schema. This gives you end-to-end type safety.

Zod's Basic Building Blocks

Zod schemas are created using the z object. Let's look at the most fundamental types: strings, numbers, and booleans.

  • z.string(): For text values.
  • z.number(): For numeric values.
  • z.boolean(): For true/false values.

These are your starting points for defining data shapes.

Declaring a String Schema

A string schema is simple to declare. You then use the .parse() method to validate data against it. If the data doesn't match, Zod throws an error.

Try running this example to see a valid string being parsed:

import { z } from 'zod';

function runExample() {
  const usernameSchema = z.string();

  const validUsername = "CoddyUser";
  const parsedUsername = usernameSchema.parse(validUsername);
  console.log(`Parsed: ${parsedUsername}`);
}

runExample();

Handling String Validation Errors

What happens if you try to parse data that isn't a string? Zod throws a ZodError. It's good practice to wrap .parse() calls in a try...catch block.

Run this code to see Zod catch an invalid type:

import { z } from 'zod';

function runExample() {
  const usernameSchema = z.string();

  try {
    const invalidUsername = 123; // Not a string!
    usernameSchema.parse(invalidUsername);
  } catch (error: any) {
    console.log(`Error: ${error.message.split('\n')[0]}`);
  }
}

runExample();

Number & Boolean Schemas

Number and boolean schemas work similarly. They ensure the data is of the correct primitive type. This prevents unexpected errors later in your application.

Let's see how to define and use them:

import { z } from 'zod';

function runExample() {
  const ageSchema = z.number();
  const isActiveSchema = z.boolean();

  const validAge = ageSchema.parse(30);
  console.log(`Age: ${validAge}`);

  const validStatus = isActiveSchema.parse(true);
  console.log(`Active: ${validStatus}`);

  try {
    ageSchema.parse("twenty"); // Invalid!
  } catch (error: any) {
    console.log(`Error (Age): ${error.message.split('\n')[0]}`);
  }
}

runExample();

Making Fields Optional

Sometimes a piece of data might not always be present. Zod provides the .optional() method for this. It makes a schema accept undefined in addition to its base type.

Note that .optional() allows undefined, but not null by default.

import { z } from 'zod';

function runExample() {
  const taglineSchema = z.string().optional();

  const withTagline = taglineSchema.parse("Hello World!");
  console.log(`With tagline: ${withTagline}`);

  const withoutTagline = taglineSchema.parse(undefined);
  console.log(`Without tagline: ${withoutTagline}`);

  try {
    taglineSchema.parse(null); // Optional doesn't allow null!
  } catch (error: any) {
    console.log(`Error (null): ${error.message.split('\n')[0]}`);
  }
}

runExample();

Exact Values with Literals

What if you need a field to have a very specific, fixed value? Zod's .literal() method is perfect for this. It ensures the parsed value is exactly what you define.

This is useful for enum-like fields where values are known beforehand.

import { z } from 'zod';

function runExample() {
  const statusSchema = z.literal("pending");

  const validStatus = statusSchema.parse("pending");
  console.log(`Valid status: ${validStatus}`);

  try {
    statusSchema.parse("completed"); // Not 'pending'!
  } catch (error: any) {
    console.log(`Error (status): ${error.message.split('\n')[0]}`);
  }
}

runExample();

Building Blocks for Complex Data

You've now seen the basic types and modifiers in Zod. While simple on their own, these are the fundamental building blocks.

In upcoming lessons, you'll learn how to combine these basic schemas to define much more complex data structures, like objects and arrays, ensuring robust validation for your entire application.

Check Your Zod Basics!

Which Zod schema correctly validates a variable that must be the string "admin" or optionally a number?

Zod Basics Recap

Great job! You've taken your first steps into Zod, understanding its core purpose and basic types.

  • Zod provides runtime validation for TypeScript data.
  • z.string(), z.number(), z.boolean() define basic types.
  • .parse() validates data and infers types.
  • Use try...catch for error handling.
  • .optional() allows undefined values.
  • z.literal() enforces exact fixed values.

These skills are foundational for building robust, type-safe applications!

Domande Frequenti

La lezione «Introduzione agli schemi Zod» è gratuita?

Sì — il testo completo di «Introduzione agli schemi Zod» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso tRPC End-to-End Type Safe APIs, passa a CoddyKit PRO. Il corso tRPC End-to-End Type Safe APIs include 4 lezioni in totale.

Cosa imparerò in «Introduzione agli schemi Zod»?

Esplori Zod, una libreria TypeScript-first per la dichiarazione e la validazione degli schemi, e i suoi tipi di base. Eserciti tRPC End-to-End Type Safe APIs con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare tRPC End-to-End Type Safe APIs?

Non è richiesta alcuna esperienza precedente. tRPC End-to-End Type Safe APIs su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Introduzione agli schemi Zod»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione tRPC End-to-End Type Safe APIs?

Sì. Ogni lezione tRPC End-to-End Type Safe APIs include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Introduzione agli schemi Zod
  2. Definire schemi Zod complessi
  3. Integrare Zod nelle procedure tRPC
  4. Trasformare e perfezionare i dati con Zod
← Torna a tRPC End-to-End Type Safe APIs