0Pricing
TypeScript Academy · Pelajaran

Perbandingan Tingkat Jenis

Bandingkan angka sepenuhnya pada tingkat jenis.

Perbandingan Tingkat Jenis 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.

Membandingkan Bilangan

Untuk membandingkan tipe literal numerik, Anda kembali mengandalkan tupel. Gagasannya adalah mengurangi kedua bilangan secara bersamaan dan melihat bilangan mana yang mencapai nol lebih dulu. Bilangan yang lebih dahulu mencapai tupel kosong adalah bilangan yang lebih kecil.

type BuildTuple<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;

Kesamaan Literal

Kesamaan literal numerik menggunakan kemampuan saling ditetapkan. Dua literal sama ketika masing-masing dapat memperluas yang lain. Membungkusnya dalam tupel mencegah kejutan gabungan.

type NumEquals<A extends number, B extends number> =
  [A] extends [B] ? ([B] extends [A] ? true : false) : false;

type X = NumEquals<3, 3>; // true
type Y = NumEquals<3, 4>; // false

Lebih Besar dari dengan Pengurangan Bertahap

Untuk A > B, bangun tupel untuk keduanya dan hapus satu elemen dari masing-masing pada setiap langkah. Jika B menjadi kosong lebih dahulu sementara A masih memiliki elemen, berarti A lebih besar.

type GreaterThan<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, unknown, ...unknown[]]
    ? true : false;

type X = GreaterThan<5, 3>; // true
type Y = GreaterThan<3, 5>; // false

Cara Membaca Polanya

Pola [...BuildTuple<B>, unknown, ...unknown[]] berarti: awalan dengan panjang B, lalu setidaknya satu elemen tambahan. Jika A cocok dengan pola itu, A memiliki lebih banyak elemen daripada B, sehingga A > B.

type A = GreaterThan<4, 4>; // false (no extra element)
type B = GreaterThan<6, 2>; // true

Lebih Kecil dari

LessThan hanyalah GreaterThan dengan argumen yang dibalik. Gunakan kembali, bukan turunkan ulang.

type LessThan<A extends number, B extends number> =
  GreaterThan<B, A>;

type X = LessThan<3, 5>; // true
type Y = LessThan<5, 3>; // false

Lebih Besar atau Sama dengan

Gabungkan perbandingan dengan kesamaan. A >= B benar ketika A > B atau A == B.

type Gte<A extends number, B extends number> =
  GreaterThan<A, B> extends true
    ? true
    : NumEquals<A, B>;

type X = Gte<5, 5>; // true
type Y = Gte<3, 5>; // false

Perbandingan Rekursif

Pendekatan lain membandingkan bilangan dengan mengurangi satu dari keduanya hingga salah satunya mencapai nol. Ini memperlihatkan gagasan langkah bersamaan secara jelas: bilangan yang mencapai nol lebih dahulu adalah bilangan yang lebih kecil.

type Cmp<A extends number, B extends number> =
  A extends 0
    ? (B extends 0 ? "eq" : "lt")
    : B extends 0
      ? "gt"
      : Cmp<Dec<A>, Dec<B>>;

type X = Cmp<3, 5>; // "lt"

Ketergantungan pada Pengurangan Satu

Versi rekursif memerlukan Dec dari pelajaran sebelumnya. Setiap langkah menghapus satu tanda dari setiap sisi. Jika keduanya nol, keduanya sama; jika hanya salah satunya nol, yang lain lebih besar.

type Dec<N extends number> =
  BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;

Kesamaan vs Kemampuan Ditetapkan

Berhati-hatilah: number extends number bernilai benar, tetapi itu bukan kesamaan literal. Perbandingan di sini mengasumsikan tipe literal tertentu seperti 3 dan 5, bukan tipe number yang luas.

type A = NumEquals<3, 3>;          // true
type B = 3 extends number ? 1 : 0; // 1 (assignability, not equality)

Membangun Kunci Pengurutan

Dengan perbandingan, Anda dapat menyandikan aturan pengurutan. Misalnya, tentukan pada tingkat tipe apakah tupel yang berisi dua bilangan diurutkan secara menaik.

type IsSorted<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? false : true;

type X = IsSorted<2, 5>; // true
type Y = IsSorted<5, 2>; // false

Gunakan Secukupnya

Perbandingan menghabiskan rekursi. Perbandingan sangat baik untuk melindungi nilai kecil dengan batas tertentu (indeks, batas tetap), tetapi bukan pustaka numerik umum. Pertahankan operan tetap kecil dan utamakan bentuk pola awalan, yang lebih dangkal daripada rekursi langkah bersamaan penuh.

type A = GreaterThan<9, 4>; // true (cheap, prefix pattern)

Pemeriksaan Singkat

Ujilah pemahaman Anda tentang perbandingan tingkat tipe.

Ringkasan

Sekarang Anda dapat mengurutkan bilangan dalam sistem tipe.

  • Kesamaan melalui kemampuan saling menetapkan pada literal.
  • GreaterThan melalui awalan sepanjang B ditambah satu elemen.
  • LessThan membalik argumen; Gte menambahkan kesamaan.
  • Bekerja pada bilangan literal kecil, bukan tipe number yang luas.

Berikutnya: mengubah semua ini menjadi utilitas praktis.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Perbandingan Tingkat Jenis” gratis?

Ya — teks lengkap “Perbandingan Tingkat 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 “Perbandingan Tingkat Jenis”?

Bandingkan angka sepenuhnya pada tingkat jenis. 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 “Perbandingan Tingkat 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

  1. Menghitung dengan Panjang Tuple
  2. Penjumlahan dan Pengurangan Tingkat Jenis
  3. Perbandingan Tingkat Jenis
  4. Utilitas Jenis Numerik Praktis
← Kembali ke TypeScript Academy