0Pricing
TypeScript Academy · Lección

Composición y refinamiento de esquemas

Cree esquemas complejos con refine, transform y uniones.

Composición y refinamiento de esquemas es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 4 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.

Los esquemas se pueden combinar

Los esquemas de Zod son bloques de construcción combinables. Puede refinarlos, transformarlos, ampliarlos y combinarlos para modelar reglas de validación complejas.

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

Reglas personalizadas con refine

.refine añade un predicado de validación personalizado con un mensaje de error para reglas que Zod no incluye de forma integrada.

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.

Refinar entre campos

Aplique .refine a un objeto para validar las relaciones entre sus campos, como la coincidencia entre una contraseña y su confirmación.

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.

Transformar valores

.transform convierte un valor validado en otra estructura después de que la validación se complete correctamente.

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

Campos opcionales

.optional() permite que falte un campo, algo que se refleja tanto en la validación como en el tipo inferido.

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

Valores predeterminados

.default proporciona un valor cuando falta la entrada, por lo que el resultado analizado siempre tiene el campo completo.

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

Esquemas de unión

z.union acepta un valor que coincida con cualquiera de varios esquemas, el equivalente de Zod a una unión de TypeScript.

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

Uniones discriminadas en Zod

z.discriminatedUnion valida uniones etiquetadas de forma eficiente mediante un campo discriminante.

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.

Combinar con extend

.extend añade campos a un esquema de objeto existente, lo que permite construir esquemas más grandes a partir de otros más pequeños.

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

Combinar esquemas de objetos

También puede combinar dos esquemas de objetos con .merge, uniendo todos sus campos en un único esquema.

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 }

Encadenarlo todo

Los refinamientos, las transformaciones, los valores predeterminados y las extensiones se pueden encadenar de forma fluida para expresar una validación completa en un único esquema legible.

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.

Comprobación rápida: combinar esquemas

Compruebe cuánto entiende sobre la combinación y el refinamiento de esquemas.

Repaso: combinar y refinar esquemas

Ha aprendido a añadir reglas personalizadas con .refine, cambiar la estructura de los valores con .transform, gestionar datos ausentes con .optional y .default, combinar alternativas con z.union y ampliar esquemas con .extend y .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.

Preguntas frecuentes

¿La lección «Composición y refinamiento de esquemas» es gratis?

Sí — el texto completo de «Composición y refinamiento de esquemas» 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 «Composición y refinamiento de esquemas»?

Cree esquemas complejos con refine, transform y uniones. 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 4 de 4.

¿Cuánto tiempo toma la lección «Composición y refinamiento de esquemas»?

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