0Pricing
TypeScript Academy · Pelajaran

Rekursi Tingkat Jenis

Lakukan perulangan pada jenis menggunakan jenis kondisional rekursif.

Rekursi 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.

Rekursi dalam Tipe

Sebuah tipe kondisional dapat merujuk pada dirinya sendiri. Dengan begitu, bahasa tipe memiliki perulangan. Sebagian besar rekursi pada tingkat tipe menelusuri sebuah tupel satu elemen demi satu elemen, melepaskan bagian kepala lalu melakukan rekursi pada bagian ekor.

type Length<T extends unknown[]> =
  T extends [unknown, ...infer Rest]
    ? Length<Rest>
    : 0;
// (this counts down to a base case)

Kasus Dasar

Setiap rekursi memerlukan kondisi penghentian. Untuk tupel, biasanya kondisi ini adalah tupel kosong. Saat pola [head, ...rest] tidak lagi cocok, berarti Anda telah mencapai akhir dan mengembalikan hasil tetap.

type IsEmpty<T extends unknown[]> =
  T extends [] ? true : false;

type A = IsEmpty<[]>;     // true
type B = IsEmpty<[1, 2]>; // false

Kepala dan Ekor

Langkah inti adalah memisahkan tupel menjadi elemen pertama dan tupel yang tersisa, menggunakan infer bersama pola sebar.

type Head<T extends unknown[]> = T extends [infer H, ...unknown[]] ? H : never;
type Tail<T extends unknown[]> = T extends [unknown, ...infer R] ? R : [];

type A = Head<[1, 2, 3]>; // 1
type B = Tail<[1, 2, 3]>; // [2, 3]

Memproses Elemen Satu per Satu

Gabungkan kepala, ekor, dan rekursi untuk mengubah seluruh tupel. ToStrings membangun kembali tupel dengan mengganti setiap tipe elemen menjadi string.

type ToStrings<T extends unknown[]> =
  T extends [infer H, ...infer R]
    ? [string, ...ToStrings<R>]
    : [];

type A = ToStrings<[1, true, 3]>; // [string, string, string]

Pola Akumulator

Sering kali Anda membangun hasil dalam parameter tambahan yang disebut akumulator. Akumulator dimulai dalam keadaan kosong dan bertambah pada setiap langkah. Cara ini menghindari penelusuran ulang struktur dan merupakan teknik standar untuk perulangan pada tingkat tipe.

type Reverse<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer H, ...infer R]
    ? Reverse<R, [H, ...Acc]>
    : Acc;

type A = Reverse<[1, 2, 3]>; // [3, 2, 1]

Menelusuri Akumulator

Telusuri Reverse<[1,2,3]>:

  • Langkah 1: H=1, Acc menjadi [1]
  • Langkah 2: H=2, Acc menjadi [2,1]
  • Langkah 3: H=3, Acc menjadi [3,2,1]
  • Tupel kosong, kembalikan Acc = [3,2,1]

Akumulator membawa hasil ke bawah pada setiap pemanggilan rekursif.

type R = Reverse<["a", "b"]>; // ["b", "a"]

Rekursi pada Gabungan

Anda juga dapat melakukan rekursi untuk menggabungkan gabungan teks. Di sini kita menggabungkan elemen-elemen tupel menjadi satu tipe literal teks, yang dipisahkan oleh pembatas.

Notasi: TypeScript yang sebenarnya menulis tipe literal templat dengan string yang dibatasi tanda backtick dan berisi celah dollar-brace. Dalam cuplikan ini, kami menampilkan pola tersebut sebagai Tpl<...>, dengan mencantumkan setiap bagian sesuai urutannya; misalnya, templat backtick yang cocok dengan awalan literal lalu Rest ditulis sebagai Tpl<'prefix', infer Rest>.

type Join<T extends string[], Sep extends string = ','> =
  T extends [infer H extends string, ...infer R extends string[]]
    ? R extends []
      ? H
      : Tpl<H, Sep, Join<R, Sep>>
    : '';
// Tpl<H, Sep, ...> builds a template literal type joining the parts

type A = Join<['a', 'b', 'c']>; // 'a,b,c'

Menghitung dengan Rekursi

Rekursi ditambah akumulator dapat digunakan untuk menghitung. Bangun tupel berisi unknown dengan panjang yang sama seperti masukan, lalu baca length-nya. Anda akan sering menggunakan teknik ini dalam kursus aritmetika.

type Count<T extends unknown[], Acc extends unknown[] = []> =
  T extends [unknown, ...infer R]
    ? Count<R, [unknown, ...Acc]>
    : Acc["length"];

type A = Count<["x", "y", "z"]>; // 3

Menyaring dengan Rekursi

Telusuri sebuah tupel dan pertahankan hanya elemen yang sesuai dengan suatu kondisi, lalu buang elemen lainnya. Lewati sebuah elemen dengan tidak menambahkannya ke akumulator.

type KeepStrings<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer H, ...infer R]
    ? H extends string
      ? KeepStrings<R, [...Acc, H]>
      : KeepStrings<R, Acc>
    : Acc;

type A = KeepStrings<[1, "a", 2, "b"]>; // ["a", "b"]

Batas Kedalaman Rekursi

Kompilator membatasi kedalaman rekursi (secara historis sekitar 50, dengan optimasi rekursi ekor yang memungkinkan kedalaman lebih besar pada beberapa pola). Untuk tupel yang sangat besar, Anda mungkin menemui Instansiasi tipe terlalu dalam. Gunakan gaya akumulator (ekor) untuk meningkatkan batas tersebut.

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

type A = Repeat<0, 3>; // [0, 0, 0]

Menggabungkan Semuanya

Pemisahan kepala/ekor, kasus dasar, dan akumulator adalah tiga bahan utama dari hampir setiap perulangan pada tingkat tipe. Dengan ketiganya, Anda dapat memetakan, menyaring, membalik, menghitung, dan menggabungkan tupel sepenuhnya dalam sistem tipe.

type MapToPairs<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer H, ...infer R]
    ? MapToPairs<R, [...Acc, [H, H]]>
    : Acc;

type A = MapToPairs<[1, 2]>; // [[1, 1], [2, 2]]

Pemeriksaan Singkat

Uji pemahaman Anda tentang pola akumulator.

Rangkuman

Sekarang Anda dapat menulis perulangan pada tingkat tipe.

  • Kondisional yang merujuk pada dirinya sendiri menciptakan rekursi.
  • Pisahkan tupel menjadi [H, ...R] dan lakukan rekursi pada bagian ekor.
  • Kasus dasar (tupel kosong) menghentikan perulangan.
  • Akumulator membangun hasil dan memungkinkan rekursi yang lebih dalam.

Berikutnya: bagaimana kondisional berperilaku secara khusus pada gabungan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Rekursi Tingkat Jenis” gratis?

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

Lakukan perulangan pada jenis menggunakan jenis kondisional rekursif. 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 “Rekursi 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. Jenis sebagai Bahasa Komputasi
  2. Kondisional Tingkat Jenis
  3. Rekursi Tingkat Jenis
  4. Jenis Kondisional Distributif
← Kembali ke TypeScript Academy