TypeScript Academy · Pelajaran

parse versus safeParse

Tangani keberhasilan dan kegagalan validasi dengan baik.

parse versus safeParse adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar TypeScript Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus TypeScript Academy mencakup 4 pelajaran total.

Dua Cara untuk Memvalidasi

Zod menyediakan dua metode validasi: parse, yang memunculkan kesalahan untuk data tidak valid, dan safeParse, yang justru mengembalikan objek hasil.

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

parse Memunculkan Kesalahan pada Data Tidak Valid

parse mengembalikan nilai yang telah divalidasi jika berhasil dan memunculkan ZodError jika gagal, cocok ketika data tidak valid benar-benar merupakan kejadian luar biasa.

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

Menangani Kesalahan parse

Bungkus parse dalam try/catch untuk menangani kesalahan yang dimunculkan, lalu periksa detail tentang hal yang gagal.

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 Mengembalikan Hasil

safeParse tidak pernah memunculkan kesalahan. Fungsi ini mengembalikan objek dengan success: true dan data, atau success: false dan error.

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

Mempersempit Hasil

Hasilnya adalah union terdiskriminasi berdasarkan success. Pemeriksaan tersebut mempersempit hasil menjadi data atau 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);
}

Kapan Menggunakan parse

Gunakan parse ketika masukan tidak valid merupakan bug atau seharusnya menghentikan operasi, misalnya saat membaca config yang diperlukan ketika aplikasi dimulai.

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

Kapan Menggunakan safeParse

Gunakan safeParse ketika masukan tidak valid memang diharapkan dan Anda ingin menanganinya dengan baik, misalnya saat memvalidasi pengiriman formulir pengguna.

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
}

Membaca Masalah ZodError

ZodError berisi larik issues yang menjelaskan setiap masalah: jalur, pesan, dan kode kesalahan.

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);
  }
}

Keduanya Mengembalikan Tipe Hasil Inferensi

Jika berhasil, kedua metode memberikan nilai yang telah divalidasi dengan tipe z.infer<typeof schema>, sehingga kode berikutnya memiliki tipe sepenuhnya.

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);

Memilih Metode yang Tepat

Aturan praktis: gunakan parse untuk jalur tepercaya atau kritis ketika kegagalan harus menghentikan eksekusi; gunakan safeParse untuk masukan tidak tepercaya yang harus Anda tangani tanpa membuat aplikasi berhenti.

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

Menggabungkan Kedua Gaya

Pola yang umum adalah membungkus safeParse dalam fungsi pembantu yang mengembalikan data bertipe atau kesalahan yang telah diformat, sehingga memberikan kemudahan penggunaan kedua metode.

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.

Pemeriksaan Singkat: parse vs safeParse

Uji pemahaman Anda tentang perbedaan parse dan safeParse.

Ringkasan: parse vs safeParse

Anda telah mempelajari bahwa parse memunculkan kesalahan untuk data tidak valid, sedangkan safeParse mengembalikan hasil success/error, kapan masing-masing digunakan, dan cara membaca masalah 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);

Pertanyaan yang Sering Diajukan

Apakah pelajaran “parse versus safeParse” gratis?

Ya — teks lengkap “parse versus safeParse” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus TypeScript Academy, upgrade ke CoddyKit PRO. Kursus TypeScript Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “parse versus safeParse”?

Tangani keberhasilan dan kegagalan validasi dengan baik. Kamu berlatih TypeScript Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai TypeScript Academy?

Tidak diperlukan pengalaman sebelumnya. TypeScript Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “parse versus safeParse” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran TypeScript Academy ini?

Ya. Setiap pelajaran TypeScript Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke TypeScript Academy