TypeScript Academy · Pelajaran

Menyimpulkan Jenis dari Skema

Turunkan jenis statis langsung dari skema Zod.

Menyimpulkan Jenis dari Skema adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 2 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.

Schema Membawa Informasi Tipe

Schema Zod mengetahui tipe TypeScript yang divalidasinya. z.infer mengekstrak tipe tersebut, sehingga Anda menulis bentuknya sekali.

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 }

Utilitas z.infer

z.infer<typeof schema> menghasilkan tipe statis yang divalidasi oleh schema. Perhatikan typeof: Anda meneruskan nilai schema.

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

Satu Sumber Kebenaran

Tanpa inferensi, Anda harus memelihara tipe dan schema secara terpisah, dan keduanya dapat berbeda. z.infer menjaga keduanya tetap sepenuhnya selaras.

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.

Menginferensikan Tipe Bersarang

Inferensi menangani objek dan larik bersarang, lalu menghasilkan tipe TypeScript bersarang yang lengkap dari satu schema.

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

Menggunakan Tipe Hasil Inferensi

Gunakan tipe hasil inferensi di mana pun Anda akan menggunakan tipe yang ditulis manual: parameter fungsi, variabel, dan tipe pengembalian.

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

schema.parse mengembalikan nilai yang sudah memiliki tipe hasil inferensi, sehingga kode berikutnya memiliki tipe sepenuhnya.

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

Optional dan Dapat Bernilai Null dalam Tipe

Pengubah schema mengalir ke tipe hasil inferensi. Bidang .optional() menjadi opsional dalam 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 }

Menginferensikan dari Larik Objek

Gabungkan z.array dan z.object, maka tipe hasil inferensinya adalah larik yang berisi tipe objek tersebut.

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

Mengapa typeof Diperlukan

Schema adalah nilai, jadi Anda merujuk tipenya dengan typeof schema sebelum meneruskannya ke 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.

Inferensi Melintasi Batas Modul

Ekspor schema dan tipe hasil inferensinya agar modul lain dapat memvalidasi dan menggunakan bentuk yang sama secara konsisten.

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.

Satu Definisi, Dua Dunia

Schema berfungsi untuk validasi saat program berjalan; z.infer berfungsi untuk pengetikan saat kompilasi. Satu deklarasi mendukung keduanya dan menghilangkan duplikasi.

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.

Pemeriksaan Singkat: Menginferensikan Tipe

Uji pemahaman Anda tentang menginferensikan tipe dari schema.

Ringkasan: Menginferensikan Tipe dari Schema

Anda telah mempelajari bahwa z.infer<typeof schema> menurunkan tipe TypeScript dari schema Zod, sehingga menyediakan satu sumber kebenaran untuk validasi dan tipe, termasuk bentuk bersarang, opsional, dan larik.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menyimpulkan Jenis dari Skema” gratis?

Ya — teks lengkap “Menyimpulkan Jenis dari Skema” 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 “Menyimpulkan Jenis dari Skema”?

Turunkan jenis statis langsung dari skema Zod. 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 2 dari 4.

Berapa lama pelajaran “Menyimpulkan Jenis dari Skema” 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