0Pricing
TypeScript Academy · Lección

Conceptos básicos de esquemas de Zod

Defina esquemas para tipos primitivos, objetos y arrays.

Conceptos básicos de esquemas de Zod es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Por qué validar en tiempo de ejecución?

Los tipos de TypeScript desaparecen en tiempo de ejecución. Los datos procedentes de API, formularios y archivos no tienen tipos en los límites del sistema. Zod valida esos datos en tiempo de ejecución y también le proporciona sus tipos.

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

Importar Zod

Importe el espacio de nombres z del paquete zod. Todos los constructores de esquemas están disponibles en z.

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

Esquemas de tipos primitivos

Zod ofrece constructores para tipos primitivos: z.string(), z.number() y z.boolean() validan cada uno un 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.

Validar un valor

Llame a .parse en un esquema para validarlo. Devuelve el valor si es válido y lanza un error si no lo es.

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

Esquemas de objetos

z.object describe la estructura de un objeto y asigna cada clave a un esquema para su valor.

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

Esquemas de arrays

z.array valida que un valor sea un array cuyos elementos coincidan todos con un esquema determinado.

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

Anidar esquemas

Los esquemas se pueden combinar. Un objeto puede contener arrays y otros objetos, reflejando la estructura de sus datos reales.

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.

Booleanos y números juntos

Combine varios tipos de campos en un mismo esquema 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 });

Los esquemas son valores

Un esquema de Zod es un valor normal de JavaScript que puede almacenar, pasar y reutilizar, a diferencia de un tipo de TypeScript, que solo existe en tiempo de compilación.

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.

Validar entradas desconocidas

Zod es ideal para datos de tipo unknown, como un payload JSON analizado, porque comprueba y restringe el valor de forma segura.

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

Bloques fundamentales del curso

Con z.object, z.string, z.number, z.array y z.boolean, puede describir la mayoría de los datos. A continuación inferiremos tipos de TypeScript a partir de estos esquemas.

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.

Comprobación rápida: fundamentos de Zod

Compruebe cuánto entiende sobre los fundamentos de los esquemas de Zod.

Repaso: fundamentos de los esquemas de Zod

Ha aprendido a importar z y a construir esquemas con z.object, z.string, z.number, z.array y z.boolean, y después a validar valores en tiempo de ejecución con .parse.

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

Preguntas frecuentes

¿La lección «Conceptos básicos de esquemas de Zod» es gratis?

Sí — el texto completo de «Conceptos básicos de esquemas de Zod» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conceptos básicos de esquemas de Zod»?

Defina esquemas para tipos primitivos, objetos y arrays. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Conceptos básicos de esquemas de Zod»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Conceptos básicos de esquemas de Zod
  2. Inferencia de tipos a partir de esquemas
  3. parse frente a safeParse
  4. Composición y refinamiento de esquemas
← Volver a TypeScript Academy