TypeScript Academy · Pelajaran

Pemeriksaan Kelengkapan dengan never

Temukan kasus yang belum ditangani saat kompilasi dengan never.

Pelajaran 3 dari 413 langkah

Pemeriksaan Kelengkapan dengan never 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.

Masalah Kelengkapan Kasus

Saat Anda menambahkan anggota gabungan baru, Anda dapat dengan mudah lupa menanganinya di suatu tempat. Pemeriksaan kelengkapan kasus mengubah kelalaian tersebut menjadi kesalahan kompilasi.

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

// If we add "triangle" later, we want every switch to complain.

Tipe yang Tidak Pernah Terjadi

Tipe never merepresentasikan nilai yang tidak mungkin terjadi. Jika setiap kasus telah ditangani, nilai yang mencapai cabang bawaan memiliki tipe never.

function fail(): never {
  throw new Error("unreachable");
}
// never is assignable to nothing except never itself.

Menetapkan Nilai ke never pada Kasus Bawaan

Di cabang default, tetapkan nilainya ke variabel bertipe never. Jika semua varian telah ditangani, penetapan tersebut berhasil dikompilasi; jika belum, penetapan itu menghasilkan kesalahan.

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.radius ** 2;
    case "square": return s.side ** 2;
    default:
      const _exhaustive: never = s;
      return _exhaustive;
  }
}
console.log(area({ kind: "square", side: 3 }));

Yang Terjadi Saat Anda Melupakan Sebuah Kasus

Jika Anda menambahkan anggota triangle tetapi melupakan kasusnya, s di bagian bawaan tidak lagi bertipe never, sehingga penetapan tersebut gagal saat kompilasi.

// type Shape = ... | { kind: "triangle"; base: number; height: number };
// Now in default, s is { kind: "triangle"; ... }
// const _exhaustive: never = s; // Error: triangle not assignable to never

Pembantu assertNever

Fungsi assertNever yang dapat digunakan kembali memusatkan pola ini. Fungsi tersebut menerima never dan melempar kesalahan, sekaligus mendokumentasikan bahwa cabang tersebut seharusnya tidak dapat dijangkau.

function assertNever(value: never): never {
  throw new Error("Unhandled case: " + JSON.stringify(value));
}
console.log(typeof assertNever);

Menggunakan assertNever dalam Switch

Panggil assertNever(s) dalam kasus bawaan. Fungsi ini memaksakan kelengkapan kasus saat kompilasi dan memberikan kesalahan yang jelas saat program berjalan jika cabang tersebut tercapai.

function assertNever(value: never): never {
  throw new Error("Unhandled: " + JSON.stringify(value));
}
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.radius ** 2;
    case "square": return s.side ** 2;
    default: return assertNever(s);
  }
}
console.log(area({ kind: "circle", radius: 1 }).toFixed(2));

Keamanan Saat Kompilasi dan Saat Berjalan

Pemeriksaan never menemukan kasus yang hilang sebelum Anda menjalankan kode, sedangkan kesalahan yang dilemparkan melindungi Anda jika sesuatu lolos dari pemeriksaan tipe saat program berjalan.

function assertNever(x: never): never {
  throw new Error("Unhandled: " + String(x));
}
// Compile error if a case is missing; runtime throw as a backstop.
console.log("two layers of safety");

Kelengkapan Kasus Tanpa Default

Jika fungsi Anda memiliki tipe pengembalian eksplisit dan sebuah switch mencakup setiap kasus, TypeScript juga dapat menandai pengembalian yang hilang, yang merupakan bentuk lain dari pemeriksaan kelengkapan kasus.

type Light = "red" | "yellow" | "green";
function next(l: Light): Light {
  switch (l) {
    case "red": return "green";
    case "yellow": return "red";
    case "green": return "yellow";
  }
  // No default needed; all cases return.
}
console.log(next("red"));

Kelengkapan Kasus dengan Rangkaian If/Else

Gagasan yang sama berlaku untuk if/else. Setelah menangani setiap varian, else terakhir menerima nilai bertipe never.

function assertNever(x: never): never { throw new Error("bad"); }
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function name(s: Shape): string {
  if (s.kind === "circle") return "circle";
  else if (s.kind === "square") return "square";
  else return assertNever(s);
}
console.log(name({ kind: "square", side: 2 }));

Mengapa never Merupakan Alat yang Tepat

Karena never tidak dapat ditetapkan ke tipe apa pun, varian yang tersisa akan menggagalkan penetapan tersebut. Inilah yang membuat never menjadi pendeteksi sempurna untuk kasus yang belum ditangani.

// Only never is assignable to never.
let x: never;
// x = "hi"; // Error
// Any concrete leftover type fails the same way.
console.log("never catches gaps");

Kelengkapan Kasus sebagai Jaring Pengaman Refaktor

Dengan assertNever di setiap tempat yang diperlukan, penambahan anggota gabungan akan menghasilkan daftar kesalahan kompilasi yang rapi dan menunjuk tepat ke setiap tempat yang harus Anda perbarui.

function assertNever(x: never): never { throw new Error("unhandled"); }
type Status = "idle" | "busy";
function render(s: Status): string {
  switch (s) {
    case "idle": return "Idle";
    case "busy": return "Busy";
    default: return assertNever(s);
  }
}
console.log(render("idle"));

Pemeriksaan Singkat: Kelengkapan Kasus

Uji pemahaman Anda tentang pemeriksaan kelengkapan kasus.

Jawab di pelajaran interaktif

Rangkuman: Kelengkapan Kasus dengan Tipe yang Tidak Pernah Terjadi

Anda telah mempelajari cara menetapkan nilai bawaan ke never (atau meneruskannya ke assertNever) agar kompiler memaksa Anda menangani setiap varian. Dengan demikian, kasus yang terlupakan menjadi kesalahan kompilasi.

function assertNever(x: never): never { throw new Error("unhandled"); }
type Shape = { kind: "circle"; radius: number } | { kind: "square"; side: number };
function f(s: Shape) {
  switch (s.kind) {
    case "circle": return s.radius;
    case "square": return s.side;
    default: return assertNever(s);
  }
}
console.log(f({ kind: "circle", radius: 5 }));

Gratis untuk memulai

Belajar TypeScript dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 101
Pelajaran: 352

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pemeriksaan Kelengkapan dengan never” gratis?

Ya — teks lengkap “Pemeriksaan Kelengkapan dengan never” 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 “Pemeriksaan Kelengkapan dengan never”?

Temukan kasus yang belum ditangani saat kompilasi dengan never. 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 “Pemeriksaan Kelengkapan dengan never” 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