0Pricing
TypeScript Academy · Aula

Composição e Refinamento de Esquemas

Crie esquemas complexos com refine, transform e uniões.

Composição e Refinamento de Esquemas é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 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 são combináveis

Os schemas do Zod são blocos de construção combináveis. Você pode refiná-los, transformá-los, estendê-los e combiná-los para modelar regras de validação complexas.

import { z } from "zod";
const base = z.object({ name: z.string() });
// We will add rules and combine schemas from here.

Regras personalizadas com refine

.refine adiciona um predicado de validação personalizado com uma mensagem de erro para regras que o Zod não oferece por padrão.

import { z } from "zod";
const password = z.string().refine(
  (s) => s.length >= 8,
  { message: "Must be at least 8 characters" }
);
// password.parse("short") throws with that message.

Refinando entre campos

Aplique .refine a um objeto para validar relações entre campos, como a confirmação de uma senha correspondente.

import { z } from "zod";
const form = z.object({
  password: z.string(),
  confirm: z.string()
}).refine((d) => d.password === d.confirm, {
  message: "Passwords must match"
});
// Validates both fields together.

Transformando valores

.transform converte um valor validado em outro shape, depois que a validação é concluída com sucesso.

import { z } from "zod";
const trimmed = z.string().transform((s) => s.trim());
const result = trimmed.parse("  hi  "); // "hi"

Campos opcionais

.optional() permite que um campo esteja ausente, o que se reflete tanto na validação quanto no tipo inferido.

import { z } from "zod";
const schema = z.object({
  name: z.string(),
  bio: z.string().optional()
});
// bio may be omitted.

Valores padrão

.default fornece um valor quando a entrada está ausente, garantindo que o resultado analisado sempre tenha o campo preenchido.

import { z } from "zod";
const schema = z.object({
  retries: z.number().default(3)
});
const r = schema.parse({}); // { retries: 3 }

Schemas de união

z.union aceita um valor que corresponda a qualquer um de vários schemas, o equivalente do Zod a uma união do TypeScript.

import { z } from "zod";
const id = z.union([z.string(), z.number()]);
// id.parse("abc") and id.parse(123) both succeed.

Uniões discriminadas no Zod

z.discriminatedUnion valida uniões marcadas com eficiência, alternando com base em um campo discriminador.

import { z } from "zod";
const shape = z.discriminatedUnion("kind", [
  z.object({ kind: z.literal("circle"), radius: z.number() }),
  z.object({ kind: z.literal("square"), side: z.number() })
]);
// Picks the right member by kind.

Mesclando com extend

.extend adiciona campos a um schema de objeto existente, permitindo criar schemas maiores a partir de outros menores.

import { z } from "zod";
const base = z.object({ id: z.number() });
const user = base.extend({ name: z.string() });
// user validates { id: number; name: string }

Combinando schemas de objetos

Você também pode mesclar dois schemas de objetos com .merge, combinando todos os campos deles em um único schema.

import { z } from "zod";
const a = z.object({ x: z.number() });
const b = z.object({ y: z.string() });
const combined = a.merge(b);
// combined validates { x: number; y: string }

Encadeando tudo

Refinamentos, transformações, valores padrão e extensões podem ser encadeados de forma fluida para expressar uma validação rica em um único schema legível.

import { z } from "zod";
const signup = z.object({
  email: z.string().refine(s => s.includes("@"), { message: "Invalid email" }),
  age: z.number().default(18)
}).extend({
  newsletter: z.boolean().optional()
});
// One schema, many rules.

Verificação rápida: compondo schemas

Teste sua compreensão sobre composição e refinamento de schemas.

Recapitulação: compondo e refinando schemas

Você aprendeu a adicionar regras personalizadas com .refine, remodelar valores com .transform, lidar com dados ausentes usando .optional e .default, combinar alternativas com z.union e ampliar schemas com .extend e .merge.

import { z } from "zod";
const schema = z.object({ name: z.string() })
  .extend({ age: z.number().default(0) })
  .refine(d => d.name.length > 0, { message: "Name required" });
// Composed validation in one place.

Perguntas Frequentes

A aula “Composição e Refinamento de Esquemas” é grátis?

Sim — o texto completo de “Composição e Refinamento 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 “Composição e Refinamento de Esquemas”?

Crie esquemas complexos com refine, transform e uniões. 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 4 de 4.

Quanto tempo leva a aula “Composição e Refinamento 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

  1. Fundamentos dos Esquemas Zod
  2. Inferindo Tipos a partir de Esquemas
  3. parse versus safeParse
  4. Composição e Refinamento de Esquemas
← Voltar para TypeScript Academy