PricingLoginStart free
TypeScript Academy · Lección

Inferencia de tipos a partir de esquemas

Derive tipos estáticos directamente de esquemas de Zod.

Lección 2 de 413 pasos

Inferencia de tipos a partir de esquemas es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 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 contienen información de tipos

Un esquema de Zod conoce el tipo de TypeScript que valida. z.infer extrae ese tipo, por lo que solo tiene que escribir la estructura una vez.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
// User is { name: string; age: number }

La utilidad z.infer

z.infer<typeof schema> produce el tipo estático que valida el esquema. Observe typeof: debe pasar el valor del esquema.

import { z } from "zod";
const tagSchema = z.array(z.string());
type Tags = z.infer<typeof tagSchema>; // string[]

Una única fuente de verdad

Sin inferencia, tendría que mantener un tipo y un esquema por separado, y podrían desincronizarse. z.infer los mantiene perfectamente sincronizados.

import { z } from "zod";
const schema = z.object({ id: z.number(), email: z.string() });
type Account = z.infer<typeof schema>;
// Change the schema, the type updates automatically.

Inferir tipos anidados

La inferencia gestiona objetos y arrays anidados, y produce el tipo completo de TypeScript anidado a partir de un único esquema.

import { z } from "zod";
const postSchema = z.object({
  title: z.string(),
  author: z.object({ name: z.string() }),
  tags: z.array(z.string())
});
type Post = z.infer<typeof postSchema>;
// Post.author.name is string

Usar el tipo inferido

Use el tipo inferido en cualquier lugar en el que usaría un tipo escrito manualmente: parámetros de funciones, variables y tipos de retorno.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
function greet(u: User): string {
  return "Hi " + u.name;
}

Parse devuelve el tipo inferido

schema.parse devuelve un valor que ya tiene el tipo inferido, por lo que el código posterior está completamente tipado.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
const raw: unknown = { name: "Ada", age: 36 };
const user: User = userSchema.parse(raw); // typed and validated

Opcional y anulable en el tipo

Los modificadores del esquema se reflejan en el tipo inferido. Un campo con .optional() se convierte en opcional en TypeScript.

import { z } from "zod";
const schema = z.object({
  name: z.string(),
  nickname: z.string().optional()
});
type P = z.infer<typeof schema>;
// P is { name: string; nickname?: string }

Inferir a partir de arrays de objetos

Combine z.array y z.object para que el tipo inferido sea un array del tipo de objeto.

import { z } from "zod";
const usersSchema = z.array(z.object({ id: z.number() }));
type Users = z.infer<typeof usersSchema>;
// Users is { id: number }[]

Por qué se necesita typeof

El esquema es un valor, por lo que debe hacer referencia a su tipo con typeof schema antes de pasarlo a z.infer.

import { z } from "zod";
const s = z.string();
type S = z.infer<typeof s>; // string
// z.infer<s> would be wrong: s is a value, not a type.

Inferencia entre límites de módulos

Exporte tanto el esquema como su tipo inferido para que otros módulos puedan validar y usar la misma estructura de forma coherente.

import { z } from "zod";
export const userSchema = z.object({ name: z.string() });
export type User = z.infer<typeof userSchema>;
// Consumers import both the runtime schema and the type.

Una definición, dos mundos

El esquema se encarga de la validación en tiempo de ejecución; z.infer, del tipado en tiempo de compilación. Una sola declaración permite ambas cosas y elimina la duplicación.

import { z } from "zod";
const configSchema = z.object({ port: z.number(), host: z.string() });
type Config = z.infer<typeof configSchema>;
// Validate at runtime, type at compile time, no drift.

Comprobación rápida: inferir tipos

Compruebe cuánto entiende sobre la inferencia de tipos a partir de esquemas.

Responde en la lección interactiva

Repaso: inferir tipos a partir de esquemas

Ha aprendido que z.infer<typeof schema> deriva un tipo de TypeScript a partir de un esquema de Zod, lo que proporciona una única fuente de verdad para la validación y los tipos, incluidas las estructuras anidadas, opcionales y de arrays.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
type User = z.infer<typeof userSchema>;
// User stays in sync with the schema automatically.
Gratis para empezar

Aprende TypeScript con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
101
Lecciones
352
Empezar a aprender gratisVer el curso completo

Preguntas frecuentes

¿La lección «Inferencia de tipos a partir de esquemas» es gratis?

Sí — el texto completo de «Inferencia de tipos a partir 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 «Inferencia de tipos a partir de esquemas»?

Derive tipos estáticos directamente de esquemas de Zod. 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 2 de 4.

¿Cuánto tiempo toma la lección «Inferencia de tipos a partir 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