tRPC End-to-End Type Safe APIs · Lekcja

Wprowadzenie do schematów Zod

Poznają Państwo Zod — bibliotekę TypeScript-first do deklarowania i walidowania schematów — oraz jej podstawowe typy.

Lekcja 1 z 411 kroki

Wprowadzenie do schematów Zod to bezpłatna lekcja tRPC End-to-End Type Safe APIs na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej tRPC End-to-End Type Safe APIs, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs tRPC End-to-End Type Safe APIs zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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?

Odpowiedz w interaktywnej lekcji

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!

Bezpłatny start

Ucz się tRPC End-to-End Type Safe APIs dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 10
Lekcje: 40

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Wprowadzenie do schematów Zod” jest bezpłatna?

Tak — pełny tekst „Wprowadzenie do schematów Zod” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu tRPC End-to-End Type Safe APIs, przejdź na CoddyKit PRO. Kurs tRPC End-to-End Type Safe APIs zawiera 4 lekcji w sumie.

Co nauczysz się w „Wprowadzenie do schematów Zod”?

Poznają Państwo Zod — bibliotekę TypeScript-first do deklarowania i walidowania schematów — oraz jej podstawowe typy. Ćwiczysz tRPC End-to-End Type Safe APIs z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć tRPC End-to-End Type Safe APIs?

Nie wymagamy żadnego doświadczenia. tRPC End-to-End Type Safe APIs w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Wprowadzenie do schematów Zod”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji tRPC End-to-End Type Safe APIs?

Tak. Każda lekcja tRPC End-to-End Type Safe APIs zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Wprowadzenie do schematów Zod
Definiowanie złożonych schematów Zod
Integracja Zod z procedurami tRPC
Przekształcanie i doprecyzowywanie danych Zod

← Powrót do tRPC End-to-End Type Safe APIs