TypeScript Academy · Lezione

Inferire i tipi dagli schemi

Derivi direttamente gli static type dagli schemi Zod.

Inferire i tipi dagli schemi è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 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 TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Gli schemi contengono informazioni sui tipi

Uno schema Zod conosce il tipo TypeScript che convalida. z.infer estrae quel tipo, così la struttura viene scritta una sola volta.

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 }

L'utility z.infer

z.infer<typeof schema> produce il tipo statico convalidato dallo schema. Noti typeof: viene passato il valore dello schema.

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

Un'unica fonte di verità

Senza l'inferenza dovrebbe mantenere separatamente un tipo e uno schema, che potrebbero divergere. z.infer li mantiene perfettamente sincronizzati.

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.

Inferire i tipi annidati

L'inferenza gestisce oggetti e array annidati, producendo il tipo TypeScript annidato completo a partire da un unico schema.

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

Utilizzare il tipo inferito

Utilizzi il tipo inferito ovunque utilizzerebbe un tipo scritto manualmente: nei parametri delle funzioni, nelle variabili e nei tipi restituiti.

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 restituisce il tipo inferito

schema.parse restituisce un valore già tipizzato come il tipo inferito, quindi il codice successivo è completamente tipizzato.

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

Optional e nullable nel tipo

I modificatori dello schema confluiscono nel tipo inferito. Un campo con .optional() diventa opzionale in 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 }

Inferire da array di oggetti

Combinando z.array e z.object, il tipo inferito è un array del tipo dell'oggetto.

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

Perché è necessario typeof

Lo schema è un valore, quindi prima di passarlo a z.infer si fa riferimento al suo tipo con 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.

Inferenza oltre i confini dei moduli

Esporti sia lo schema sia il relativo tipo inferito, così gli altri moduli possono convalidare e utilizzare la stessa struttura in modo coerente.

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.

Una definizione, due mondi

Lo schema gestisce la convalida a runtime; z.infer gestisce la tipizzazione in fase di compilazione. Una sola dichiarazione svolge entrambe le funzioni, eliminando la duplicazione.

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.

Verifica rapida: inferire i tipi

Verifichi la Sua comprensione dell'inferenza dei tipi dagli schemi.

Riepilogo: inferire i tipi dagli schemi

Ha imparato che z.infer<typeof schema> ricava un tipo TypeScript da uno schema Zod, fornendo un'unica fonte di verità per la convalida e i tipi, comprese le strutture annidate, opzionali e gli array.

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.

Domande Frequenti

La lezione «Inferire i tipi dagli schemi» è gratuita?

Sì — il testo completo di «Inferire i tipi dagli schemi» è 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 TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Inferire i tipi dagli schemi»?

Derivi direttamente gli static type dagli schemi Zod. Eserciti TypeScript Academy 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 TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Inferire i tipi dagli schemi»?

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

Sì. Ogni lezione TypeScript Academy 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

← Torna a TypeScript Academy