TypeScript Academy · Aula

Fundamentos dos Esquemas Zod

Defina esquemas para tipos primitivos, objetos e matrizes.

Fundamentos dos Esquemas Zod é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 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.

Por que validar em tempo de execução?

Os tipos do TypeScript desaparecem em tempo de execução. Dados provenientes de APIs, formulários e arquivos não têm tipo na fronteira do sistema. O Zod valida esses dados em tempo de execução e também fornece os tipos.

import { z } from "zod";
// Types check at compile time; Zod checks values at runtime.

Importando o Zod

Importe o namespace z do pacote zod. Cada construtor de schema está disponível em z.

import { z } from "zod";
const nameSchema = z.string();
// nameSchema validates that a value is a string.

Schemas primitivos

O Zod oferece construtores para valores primitivos: z.string(), z.number() e z.boolean() validam, cada um, um tipo de valor.

import { z } from "zod";
const name = z.string();
const age = z.number();
const active = z.boolean();
// Use .parse(value) to validate at runtime.

Validando um valor

Chame .parse em um schema para validá-lo. Ele retorna o valor se for válido e lança uma exceção caso contrário.

import { z } from "zod";
const schema = z.string();
const result = schema.parse("hello"); // "hello"
const broken = schema.parse(123); // throws ZodError

Schemas de objetos

z.object descreve a estrutura de um objeto, associando cada chave a um schema para seu valor.

import { z } from "zod";
const userSchema = z.object({
  name: z.string(),
  age: z.number()
});
// userSchema.parse({ name: "Ada", age: 36 }) succeeds.

Schemas de matrizes

z.array valida se um valor é uma matriz cujos elementos correspondem todos a um determinado schema.

import { z } from "zod";
const tags = z.array(z.string());
// tags.parse(["a", "b"]) succeeds; tags.parse([1]) throws.

Aninhando schemas

Os schemas podem ser compostos. Um objeto pode conter matrizes e outros objetos, refletindo a estrutura dos seus dados reais.

import { z } from "zod";
const post = z.object({
  title: z.string(),
  tags: z.array(z.string()),
  author: z.object({ name: z.string() })
});
// Validates nested structure in one call.

Booleano e número juntos

Combine vários tipos de campo em um único schema de objeto para modelar registros realistas.

import { z } from "zod";
const product = z.object({
  name: z.string(),
  price: z.number(),
  inStock: z.boolean()
});
// product.parse({ name: "Pen", price: 2, inStock: true });

Schemas são valores

Um schema Zod é um valor comum de JavaScript que você pode armazenar, passar adiante e reutilizar, ao contrário de um tipo do TypeScript, que existe somente em tempo de compilação.

import { z } from "zod";
const emailSchema = z.string();
function check(s: typeof emailSchema, v: unknown) {
  return s.parse(v);
}
// You can pass schemas as arguments.

Validando uma entrada desconhecida

O Zod é ideal para dados unknown, como uma carga útil JSON analisada, porque verifica e restringe o valor com segurança.

import { z } from "zod";
const schema = z.object({ id: z.number() });
const raw: unknown = JSON.parse("{ \"id\": 1 }");
const data = schema.parse(raw); // data.id is number

Blocos fundamentais do curso

Com z.object, z.string, z.number, z.array e z.boolean, você pode descrever a maioria dos dados. Em seguida, inferiremos tipos do TypeScript a partir desses schemas.

import { z } from "zod";
const schema = z.object({
  name: z.string(),
  scores: z.array(z.number())
});
// One schema, ready to validate and to infer a type from.

Verificação rápida: fundamentos do Zod

Teste sua compreensão dos fundamentos dos schemas do Zod.

Recapitulação: fundamentos dos schemas do Zod

Você aprendeu a importar z e criar schemas com z.object, z.string, z.number, z.array e z.boolean, além de validar valores em tempo de execução com .parse.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
// userSchema.parse({ name: "Ada", age: 36 });

Perguntas Frequentes

A aula “Fundamentos dos Esquemas Zod” é grátis?

Sim — o texto completo de “Fundamentos dos Esquemas Zod” é 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 “Fundamentos dos Esquemas Zod”?

Defina esquemas para tipos primitivos, objetos e matrizes. 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 1 de 4.

Quanto tempo leva a aula “Fundamentos dos Esquemas Zod”?

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