TypeScript Academy · Lekcja

Wnioskowanie typów ze schematów

Wyprowadzaj typy statyczne bezpośrednio ze schematów Zod

Wnioskowanie typów ze schematów to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 2 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 TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Schematy zawierają informacje o typach

Schemat Zod zna typ TypeScript, który weryfikuje. z.infer wyodrębnia ten typ, dzięki czemu strukturę zapisuje się raz.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
// User is { name: string; age: number }

Narzędzie z.infer

z.infer<typeof schema> tworzy typ statyczny, który weryfikuje schemat. Proszę zwrócić uwagę na typeof: przekazywana jest wartość schematu.

import { z } from "zod";
const tagSchema = z.array(z.string());
type Tags = z.infer<typeof tagSchema>; // string[]

Jedno źródło prawdy

Bez wnioskowania typów trzeba byłoby osobno utrzymywać typ i schemat, które mogłyby się z czasem rozbiec. z.infer zapewnia ich pełną zgodność.

import { z } from "zod";
const schema = z.object({ id: z.number(), email: z.string() });
type Account = z.infer<typeof schema>;
// Change the schema, the type updates automatically.

Wnioskowanie typów zagnieżdżonych

Wnioskowanie typów obsługuje zagnieżdżone obiekty i tablice, tworząc pełny zagnieżdżony typ TypeScript na podstawie jednego schematu.

import { z } from "zod";
const postSchema = z.object({
  title: z.string(),
  author: z.object({ name: z.string() }),
  tags: z.array(z.string())
});
type Post = z.infer<typeof postSchema>;
// Post.author.name is string

Korzystanie z wywnioskowanego typu

Wywnioskowanego typu można używać wszędzie tam, gdzie użyłoby się typu zdefiniowanego ręcznie: jako parametrów funkcji, typów zmiennych i typów zwracanych.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
function greet(u: User): string {
  return "Hi " + u.name;
}

parse zwraca wywnioskowany typ

schema.parse zwraca wartość, która już ma typ wywnioskowany ze schematu, dzięki czemu dalszy kod jest w pełni typowany.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
const raw: unknown = { name: "Ada", age: 36 };
const user: User = userSchema.parse(raw); // typed and validated

Typy opcjonalne i nullable

Modyfikatory schematu są uwzględniane w wywnioskowanym typie. Pole z .optional() staje się opcjonalne w TypeScript.

import { z } from "zod";
const schema = z.object({
  name: z.string(),
  nickname: z.string().optional()
});
type P = z.infer<typeof schema>;
// P is { name: string; nickname?: string }

Wnioskowanie typów z tablic obiektów

Połączenie z.array i z.object daje wywnioskowany typ będący tablicą obiektów danego typu.

import { z } from "zod";
const usersSchema = z.array(z.object({ id: z.number() }));
type Users = z.infer<typeof usersSchema>;
// Users is { id: number }[]

Dlaczego potrzebne jest typeof

Schemat jest wartością, dlatego przed przekazaniem go do z.infer należy odwołać się do jego typu za pomocą typeof schema.

import { z } from "zod";
const s = z.string();
type S = z.infer<typeof s>; // string
// z.infer<s> would be wrong: s is a value, not a type.

Wnioskowanie typów między modułami

Należy eksportować zarówno schemat, jak i wywnioskowany z niego typ, aby inne moduły mogły spójnie weryfikować dane i korzystać z tej samej struktury.

import { z } from "zod";
export const userSchema = z.object({ name: z.string() });
export type User = z.infer<typeof userSchema>;
// Consumers import both the runtime schema and the type.

Jedna definicja, dwa światy

Schemat służy do walidacji w czasie działania programu, a z.infer do typowania w czasie kompilacji. Jedna deklaracja obsługuje oba zastosowania, eliminując duplikowanie kodu.

import { z } from "zod";
const configSchema = z.object({ port: z.number(), host: z.string() });
type Config = z.infer<typeof configSchema>;
// Validate at runtime, type at compile time, no drift.

Szybki test: wnioskowanie typów

Sprawdź swoją wiedzę na temat wnioskowania typów ze schematów.

Podsumowanie: wnioskowanie typów ze schematów

Dowiedział się Pan lub dowiedziała się Pani, że z.infer<typeof schema> wyprowadza typ TypeScript ze schematu Zod, zapewniając jedno źródło prawdy dla walidacji i typów, w tym struktur zagnieżdżonych, opcjonalnych i tablicowych.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
// User stays in sync with the schema automatically.

Często zadawane pytania

Czy lekcja „Wnioskowanie typów ze schematów” jest bezpłatna?

Tak — pełny tekst „Wnioskowanie typów ze schematów” 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 TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Wnioskowanie typów ze schematów”?

Wyprowadzaj typy statyczne bezpośrednio ze schematów Zod Ćwiczysz TypeScript Academy 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ąć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy 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 2 z 4.

Ile czasu zajmuje lekcja „Wnioskowanie typów ze schematów”?

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 TypeScript Academy?

Tak. Każda lekcja TypeScript Academy 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

← Powrót do TypeScript Academy