0Pricing
TypeScript Academy · Lección

parse frente a safeParse

Gestione correctamente los casos de validación exitosa y fallida.

parse frente a safeParse es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 3 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.

Dos formas de validar

Zod ofrece dos métodos de validación: parse, que lanza un error cuando los datos no son válidos, y safeParse, que devuelve un objeto de resultado.

import { z } from "zod";
const schema = z.string();
// schema.parse(x) throws on failure
// schema.safeParse(x) returns { success, ... }

parse lanza un error con datos no válidos

parse devuelve el valor validado si la operación tiene éxito y lanza un ZodError si falla, lo que resulta ideal cuando los datos no válidos representan una situación realmente excepcional.

import { z } from "zod";
const schema = z.number();
const ok = schema.parse(42); // 42
// schema.parse("nope"); // throws ZodError

Capturar errores de parse

Envuelva parse en un bloque try/catch para gestionar el error lanzado e inspeccionarlo en busca de detalles sobre lo que falló.

import { z } from "zod";
const schema = z.number();
try {
  schema.parse("nope");
} catch (err) {
  if (err instanceof z.ZodError) {
    console.log("Invalid:", err.issues.length);
  }
}

safeParse devuelve un resultado

safeParse nunca lanza un error. Devuelve un objeto con success: true y data, o con success: false y error.

import { z } from "zod";
const schema = z.number();
const result = schema.safeParse("nope");
// result is { success: false, error: ZodError }

Restringir el resultado

El resultado es una unión discriminada basada en success. Al comprobarlo, el tipo se restringe a data o a error.

import { z } from "zod";
const schema = z.object({ id: z.number() });
const result = schema.safeParse({ id: 1 });
if (result.success) {
  console.log(result.data.id); // typed
} else {
  console.log(result.error.issues);
}

Cuándo usar parse

Use parse cuando una entrada no válida sea un error de programación o deba cancelar la operación, como al leer la configuración obligatoria durante el inicio.

import { z } from "zod";
const configSchema = z.object({ port: z.number() });
const config = configSchema.parse({ port: 8080 });
// Fail fast if config is wrong.

Cuándo usar safeParse

Use safeParse cuando se espere que la entrada no sea válida y quiera gestionarla correctamente, como al validar envíos de formularios de usuarios.

import { z } from "zod";
const formSchema = z.object({ email: z.string() });
const r = formSchema.safeParse({ email: 123 });
if (!r.success) {
  // Show a friendly validation message
}

Leer los problemas de ZodError

Un ZodError contiene un array issues que describe cada problema: la ruta, un mensaje y el código de error.

import { z } from "zod";
const schema = z.object({ age: z.number() });
const r = schema.safeParse({ age: "x" });
if (!r.success) {
  for (const issue of r.error.issues) {
    console.log(issue.path, issue.message);
  }
}

Ambos devuelven el tipo inferido

Si la operación tiene éxito, ambos métodos proporcionan el valor validado con el tipo z.infer<typeof schema>, por lo que el código posterior está completamente tipado.

import { z } from "zod";
const userSchema = z.object({ name: z.string() });
type User = z.infer<typeof userSchema>;
const u: User = userSchema.parse({ name: "Ada" });
console.log(u.name);

Elegir el método adecuado

Regla práctica: use parse en rutas de confianza o críticas en las que un error deba detener la ejecución; use safeParse para entradas no confiables que deba gestionar sin provocar un fallo.

import { z } from "zod";
const schema = z.string();
// Critical: schema.parse(value)
// User-facing: schema.safeParse(value)

Combinar ambos estilos

Un patrón habitual consiste en envolver safeParse en una función auxiliar que devuelva datos tipados o un error con formato, combinando la comodidad de ambos métodos.

import { z } from "zod";
function validate<T extends z.ZodType>(schema: T, value: unknown) {
  const r = schema.safeParse(value);
  return r.success ? { ok: true, data: r.data } : { ok: false, error: r.error };
}
// Reusable, no throwing.

Comprobación rápida: parse frente a safeParse

Compruebe cuánto entiende sobre las diferencias entre parse y safeParse.

Repaso: parse frente a safeParse

Ha aprendido que parse lanza un error con datos no válidos, mientras que safeParse devuelve un resultado success/error; también ha aprendido cuándo usar cada uno y cómo leer los problemas de ZodError.

import { z } from "zod";
const schema = z.object({ id: z.number() });
const r = schema.safeParse({ id: 1 });
if (r.success) console.log(r.data.id);

Preguntas frecuentes

¿La lección «parse frente a safeParse» es gratis?

Sí — el texto completo de «parse frente a safeParse» 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 «parse frente a safeParse»?

Gestione correctamente los casos de validación exitosa y fallida. 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 3 de 4.

¿Cuánto tiempo toma la lección «parse frente a safeParse»?

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