0Pricing
tRPC End-to-End Type Safe APIs · Aula

Introdução aos esquemas Zod

Explore o Zod, uma biblioteca de declaração e validação de esquemas orientada ao TypeScript, e seus tipos básicos.

Introdução aos esquemas Zod é uma aula grátis de tRPC End-to-End Type Safe APIs 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 tRPC End-to-End Type Safe APIs, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de tRPC End-to-End Type Safe APIs inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

What is Zod?

Welcome to Zod! It's a powerful, TypeScript-first validation library. Think of it as a guardian for your data.

Zod helps ensure that the data entering your application (from APIs, forms, etc.) matches the types you expect, even at runtime.

Why Use Zod? Type Safety!

TypeScript provides type safety during development, but what about data received from a server or user input? That data doesn't have TypeScript types.

Zod bridges this gap! It allows you to define a schema, validate runtime data against it, and automatically infer a TypeScript type from that schema. This gives you end-to-end type safety.

Zod's Basic Building Blocks

Zod schemas are created using the z object. Let's look at the most fundamental types: strings, numbers, and booleans.

  • z.string(): For text values.
  • z.number(): For numeric values.
  • z.boolean(): For true/false values.

These are your starting points for defining data shapes.

Declaring a String Schema

A string schema is simple to declare. You then use the .parse() method to validate data against it. If the data doesn't match, Zod throws an error.

Try running this example to see a valid string being parsed:

import { z } from 'zod';

function runExample() {
  const usernameSchema = z.string();

  const validUsername = "CoddyUser";
  const parsedUsername = usernameSchema.parse(validUsername);
  console.log(`Parsed: ${parsedUsername}`);
}

runExample();

Handling String Validation Errors

What happens if you try to parse data that isn't a string? Zod throws a ZodError. It's good practice to wrap .parse() calls in a try...catch block.

Run this code to see Zod catch an invalid type:

import { z } from 'zod';

function runExample() {
  const usernameSchema = z.string();

  try {
    const invalidUsername = 123; // Not a string!
    usernameSchema.parse(invalidUsername);
  } catch (error: any) {
    console.log(`Error: ${error.message.split('\n')[0]}`);
  }
}

runExample();

Number & Boolean Schemas

Number and boolean schemas work similarly. They ensure the data is of the correct primitive type. This prevents unexpected errors later in your application.

Let's see how to define and use them:

import { z } from 'zod';

function runExample() {
  const ageSchema = z.number();
  const isActiveSchema = z.boolean();

  const validAge = ageSchema.parse(30);
  console.log(`Age: ${validAge}`);

  const validStatus = isActiveSchema.parse(true);
  console.log(`Active: ${validStatus}`);

  try {
    ageSchema.parse("twenty"); // Invalid!
  } catch (error: any) {
    console.log(`Error (Age): ${error.message.split('\n')[0]}`);
  }
}

runExample();

Making Fields Optional

Sometimes a piece of data might not always be present. Zod provides the .optional() method for this. It makes a schema accept undefined in addition to its base type.

Note that .optional() allows undefined, but not null by default.

import { z } from 'zod';

function runExample() {
  const taglineSchema = z.string().optional();

  const withTagline = taglineSchema.parse("Hello World!");
  console.log(`With tagline: ${withTagline}`);

  const withoutTagline = taglineSchema.parse(undefined);
  console.log(`Without tagline: ${withoutTagline}`);

  try {
    taglineSchema.parse(null); // Optional doesn't allow null!
  } catch (error: any) {
    console.log(`Error (null): ${error.message.split('\n')[0]}`);
  }
}

runExample();

Exact Values with Literals

What if you need a field to have a very specific, fixed value? Zod's .literal() method is perfect for this. It ensures the parsed value is exactly what you define.

This is useful for enum-like fields where values are known beforehand.

import { z } from 'zod';

function runExample() {
  const statusSchema = z.literal("pending");

  const validStatus = statusSchema.parse("pending");
  console.log(`Valid status: ${validStatus}`);

  try {
    statusSchema.parse("completed"); // Not 'pending'!
  } catch (error: any) {
    console.log(`Error (status): ${error.message.split('\n')[0]}`);
  }
}

runExample();

Building Blocks for Complex Data

You've now seen the basic types and modifiers in Zod. While simple on their own, these are the fundamental building blocks.

In upcoming lessons, you'll learn how to combine these basic schemas to define much more complex data structures, like objects and arrays, ensuring robust validation for your entire application.

Check Your Zod Basics!

Which Zod schema correctly validates a variable that must be the string "admin" or optionally a number?

Zod Basics Recap

Great job! You've taken your first steps into Zod, understanding its core purpose and basic types.

  • Zod provides runtime validation for TypeScript data.
  • z.string(), z.number(), z.boolean() define basic types.
  • .parse() validates data and infers types.
  • Use try...catch for error handling.
  • .optional() allows undefined values.
  • z.literal() enforces exact fixed values.

These skills are foundational for building robust, type-safe applications!

Perguntas Frequentes

A aula “Introdução aos esquemas Zod” é grátis?

Sim — o texto completo de “Introdução aos 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 tRPC End-to-End Type Safe APIs, atualize para CoddyKit PRO. O curso de tRPC End-to-End Type Safe APIs inclui 4 aulas no total.

O que vou aprender em “Introdução aos esquemas Zod”?

Explore o Zod, uma biblioteca de declaração e validação de esquemas orientada ao TypeScript, e seus tipos básicos. Você pratica tRPC End-to-End Type Safe APIs 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 tRPC End-to-End Type Safe APIs?

Nenhuma experiência prévia é necessária. tRPC End-to-End Type Safe APIs 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 “Introdução aos 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 tRPC End-to-End Type Safe APIs?

Sim. Cada aula de tRPC End-to-End Type Safe APIs 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. Introdução aos esquemas Zod
  2. Definindo esquemas Zod complexos
  3. Integrando o Zod aos procedimentos tRPC
  4. Transformando e refinando dados do Zod
← Voltar para tRPC End-to-End Type Safe APIs