TypeScript Academy · Aula

Inferindo Tipos a partir de Esquemas

Derive tipos estáticos diretamente de esquemas Zod.

Aula 2 de 413 etapas

Inferindo Tipos a partir de Esquemas é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Schemas carregam informações de tipo

Um schema Zod conhece o tipo do TypeScript que valida. z.infer extrai esse tipo, permitindo que você escreva a estrutura uma única vez.

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 }

O utilitário z.infer

z.infer<typeof schema> produz o tipo estático que o schema valida. Observe o typeof: você passa o valor do schema.

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

Uma única fonte de verdade

Sem inferência, você teria de manter um tipo e um schema separadamente, e eles poderiam divergir. z.infer mantém ambos perfeitamente sincronizados.

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.

Inferindo tipos aninhados

A inferência lida com objetos e matrizes aninhados, produzindo o tipo completo e aninhado do TypeScript a partir de um único 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

Usando o tipo inferido

Use o tipo inferido em qualquer lugar em que usaria um tipo escrito manualmente: parâmetros de função, variáveis e tipos de retorno.

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 retorna o tipo inferido

schema.parse retorna um valor já tipado como o tipo inferido, portanto o código posterior é totalmente tipado.

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

Opcional e anulável no tipo

Os modificadores do schema são incorporados ao tipo inferido. Um campo .optional() torna-se opcional no 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 }

Inferindo a partir de matrizes de objetos

Combine z.array e z.object para que o tipo inferido seja uma matriz do tipo de objeto.

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

Por que typeof é necessário

O schema é um valor, portanto você referencia seu tipo com typeof schema antes de passá-lo para z.infer.

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.

Inferência entre limites de módulos

Exporte tanto o schema quanto seu tipo inferido para que outros módulos possam validar e usar a mesma estrutura de forma consistente.

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.

Uma definição, dois mundos

O schema fornece a validação em tempo de execução; z.infer fornece a tipagem em tempo de compilação. Uma única declaração sustenta ambos, eliminando a duplicação.

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ção rápida: inferindo tipos

Teste sua compreensão sobre a inferência de tipos a partir de schemas.

Responda na aula interativa

Recapitulação: inferindo tipos a partir de schemas

Você aprendeu que z.infer<typeof schema> deriva um tipo do TypeScript a partir de um schema Zod, fornecendo uma única fonte de verdade para validação e tipos, incluindo estruturas aninhadas, opcionais e de matrizes.

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.

Grátis para começar

Aprenda TypeScript com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 101
Aulas: 352

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Inferindo Tipos a partir de Esquemas” é grátis?

Sim — o texto completo de “Inferindo Tipos a partir de Esquemas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Inferindo Tipos a partir de Esquemas”?

Derive tipos estáticos diretamente de esquemas Zod. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Inferindo Tipos a partir de Esquemas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para TypeScript Academy