TypeScript Academy · Pelajaran

Pernyataan versus Pengawal Jenis

Jika memungkinkan, utamakan pemeriksaan saat runtime daripada pernyataan.

Pernyataan versus Pengawal Jenis adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 4 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 Meyakinkan Kompiler

Ketika kompiler tidak mengetahui tipe persis suatu nilai, Anda memiliki dua pilihan: menegaskan tipenya (menyatakan bahwa tipenya demikian) atau menjaganya (membuktikan tipenya saat berjalan). Keduanya terlihat serupa, tetapi tingkat keamanannya sangat berbeda.

function viaAssert(v: unknown): number {
  return (v as number) + 1; // claim
}
function viaGuard(v: unknown): number {
  return typeof v === 'number' ? v + 1 : 0; // prove
}
console.log(viaAssert(5), viaGuard(5), viaGuard('x'));

Penegasan Tidak Melakukan Verifikasi

Penegasan adalah janji tanpa penegakan. Jika Anda keliru, kesalahan akan lolos hingga waktu berjalan. Penegasan menukar keamanan dengan kemudahan.

const v: unknown = 'hello';
const n = v as number;
console.log(n.toFixed(2)); // runtime error: toFixed is not a function

Penjaga Tipe Memverifikasi Saat Berjalan

Penjaga tipe benar-benar memeriksa nilai tersebut. Jika pemeriksaan berhasil, Anda dan kompiler sama-sama mengetahui bahwa tipenya benar—ada pengujian nyata saat berjalan yang mendukung penyempitan tipe itu.

function toFixed2(v: unknown): string {
  if (typeof v === 'number') return v.toFixed(2);
  return 'N/A';
}
console.log(toFixed2(3.14159), toFixed2('hi'));

Fungsi Penjaga Tipe Kustom

Encapsulasikan pemeriksaan yang kompleks dalam penjaga yang dapat digunakan kembali dan mengembalikan value is T. Seluruh basis kode memperoleh manfaat dari satu validasi yang teruji dengan baik.

type Email = { address: string };
function isEmail(v: unknown): v is Email {
  return typeof v === 'object' && v !== null &&
    'address' in v && typeof (v as any).address === 'string';
}
console.log(isEmail({ address: 'a@b.com' }), isEmail(null));

Penjaga Tipe Dapat Digabungkan dan Digunakan Kembali

Karena penjaga tipe adalah fungsi biasa, Anda dapat menggabungkan, menguji, dan menggunakannya kembali. Sebaliknya, penegasan adalah klaim yang tersebar dan tidak dapat divalidasi secara terpusat.

function isString(v: unknown): v is string { return typeof v === 'string'; }
function isNonEmpty(v: unknown): v is string {
  return isString(v) && v.length > 0;
}
console.log(isNonEmpty('hi'), isNonEmpty(''));

Fungsi Penegasan dengan asserts

TypeScript juga menyediakan fungsi penegasan. Anotasi pengembaliannya menggunakan kata kunci asserts. Jika fungsi kembali secara normal, kompiler mempersempit tipe argumen mulai dari titik tersebut; jika kondisinya gagal, fungsi tersebut melempar galat.

function assertNumber(v: unknown): asserts v is number {
  if (typeof v !== 'number') throw new Error('not a number');
}
function use(v: unknown): number {
  assertNumber(v); // after this line, v is number
  return v * 2;
}
console.log(use(21));

asserts dibandingkan dengan value is

Penjaga value is T mengembalikan nilai boolean yang Anda gunakan untuk membuat percabangan. Fungsi asserts value is T melempar galat saat gagal dan mempersempit tipe untuk sisa cakupan. Keduanya didukung pemeriksaan saat berjalan, berbeda dengan as biasa.

function assertDefined<T>(v: T): asserts v is NonNullable<T> {
  if (v === null || v === undefined) throw new Error('missing');
}
const maybe: string | null = 'ok';
assertDefined(maybe);
console.log(maybe.length); // narrowed to string

Pembantu Penegasan Generik

Fungsi penegasan sangat cocok digunakan sebagai prasyarat yang dapat dipakai kembali. Satu pembantu assert(condition) dapat menjaga invarian di seluruh kode Anda dan segera melempar galat ketika terjadi pelanggaran.

function assert(cond: unknown, msg: string): asserts cond {
  if (!cond) throw new Error(msg);
}
function half(n: number): number {
  assert(n % 2 === 0, 'must be even');
  return n / 2;
}
console.log(half(8));

Membandingkan Tingkat Keamanan

Urutan dari yang paling aman hingga paling berisiko: penjaga tipe dan fungsi penegasan (diperiksa saat berjalan) berada di atas penegasan as biasa (tanpa pemeriksaan), yang berada di atas penegasan ganda (secara aktif menyesatkan). Pilih alat paling aman yang sesuai.

// Safe: guard
function safe(v: unknown) {
  return typeof v === 'string' ? v.trim() : '';
}
console.log(safe('  hi  '));

Memilih Alat yang Tepat

Gunakan penjaga tipe ketika Anda membuat percabangan berdasarkan tipe. Gunakan fungsi penegasan ketika prasyarat harus terpenuhi atau eksekusi harus dihentikan. Gunakan as hanya ketika penyempitan tipe tidak mungkin dilakukan, misalnya untuk spesialisasi DOM.

function getInput(v: unknown): asserts v is string {
  if (typeof v !== 'string') throw new Error('expected string');
}
const raw: unknown = 'name';
getInput(raw);
console.log(raw.toUpperCase());

Pemeriksaan Saat Berjalan Lebih Unggul

Tema yang terus berulang dalam kursus ini: utamakan pemeriksaan saat berjalan daripada penegasan. Penjaga tipe dan fungsi penegasan memberi Anda tipe pada waktu kompilasi sekaligus keamanan saat berjalan. Penegasan hanya memberi Anda sebuah klaim.

function parsePort(v: unknown): number {
  if (typeof v === 'number' && Number.isInteger(v)) return v;
  throw new Error('invalid port');
}
console.log(parsePort(8080));

Pemeriksaan Singkat

Ujilah pemahaman Anda tentang penegasan dan penjaga tipe.

Ringkasan: Penegasan dan Penjaga Tipe

Anda telah mempelajari bahwa:

Penjaga tipe (value is T) membuktikan tipe saat berjalan dan memungkinkan Anda membuat percabangan.
Fungsi penegasan (asserts value is T) melempar galat ketika gagal dan mempersempit tipe setelahnya.
Penegasan as biasa hanya menyatakan suatu tipe—tanpa keamanan saat berjalan.
Utamakan alat yang diperiksa saat berjalan; gunakan penegasan hanya untuk kasus yang tidak dapat ditangani oleh penyempitan tipe.

Kursus berikutnya: perangkaian opsional dan penggabungan nilai kosong.

function isPositive(v: unknown): v is number {
  return typeof v === 'number' && v > 0;
}
console.log(isPositive(5), isPositive(-1));

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pernyataan versus Pengawal Jenis” gratis?

Ya — teks lengkap “Pernyataan versus Pengawal Jenis” 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 “Pernyataan versus Pengawal Jenis”?

Jika memungkinkan, utamakan pemeriksaan saat runtime daripada pernyataan. 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 4 dari 4.

Berapa lama pelajaran “Pernyataan versus Pengawal Jenis” 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