TypeScript Academy · Pelajaran

Kedalaman dan Batas Rekursi

Pahami batasan kedalaman rekursi TypeScript.

Kedalaman dan Batas Rekursi 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.

TypeScript Memiliki Batas Rekursi

Tipe rekursif sangat kuat, tetapi pemeriksa tipe membatasi seberapa dalam tipe tersebut dapat diinstansiasi. Jika batasnya tercapai, Anda mendapatkan kesalahan kedalaman.

// Excessively deep recursive types can produce:
// "Type instantiation is excessively deep and possibly infinite."

Asal Kesalahan Kedalaman

Tipe kondisional yang berekursi tanpa kasus dasar yang jelas dan terus menyusut dapat berputar tanpa akhir, terutama jika digabungkan dengan gabungan besar atau pembuatan tupel.

type Repeat<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : Repeat<N, [...Acc, unknown]>;
// Large N can exceed the instantiation depth.
type Five = Repeat<5>;

Rekursi Terbatas yang Aman

Jaga agar rekursi tetap dangkal dan terbatas. Membuat tupel kecil tidak masalah; kasus dasar Acc["length"] extends N segera menghentikannya.

type Tuple<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : Tuple<N, [...Acc, unknown]>;
type Three = Tuple<3>; // [unknown, unknown, unknown]
const t: Three = [1, 2, 3];
console.log(t.length);

Pola Tipe Rekursif Ekor

TypeScript mengoptimalkan tipe kondisional rekursif ekor tertentu dengan membawa akumulator, sehingga memungkinkan rekursi yang lebih dalam daripada penyarangan naif.

type Reverse<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer Head, ...infer Tail]
    ? Reverse<Tail, [Head, ...Acc]>
    : Acc;
type R = Reverse<[1, 2, 3]>; // [3, 2, 1]
const r: R = [3, 2, 1];
console.log(r);

Mengapa Akumulator Membantu

Meneruskan hasil melalui akumulator menjaga rekursi tetap berada pada posisi ekor, yang dapat diurai TypeScript dengan lebih efisien daripada kondisional yang sangat bertingkat.

type Join<T extends string[], Acc extends string = ""> =
  T extends [infer H extends string, ...infer R extends string[]]
    ? Join<R, Acc extends "" ? H : Acc>
    : Acc;
type First = Join<["a", "b", "c"]>; // "a"
const f: First = "a";
console.log(f);

Menghindari Rekursi Non-Ekor

Membungkus pemanggilan rekursif di dalam operasi tipe lain memindahkannya dari posisi ekor dan dapat membuat batas tercapai lebih cepat. Sebagai gantinya, bawalah status dalam akumulator.

// Non-tail (can be costly): builds nesting around the recursive call
// type Bad<T> = T extends [infer H, ...infer R] ? [H, ...Bad<R>] : [];
// Tail-friendly alternative uses an accumulator parameter.
console.log("prefer accumulators");

Membatasi Kedalaman Secara Eksplisit

Tambahkan penghitung kedalaman agar tipe berhenti setelah sejumlah tingkat tertentu, dengan menukar kelengkapan demi penghentian yang terjamin.

type Flatten<T, Depth extends unknown[] = []> =
  Depth["length"] extends 5
    ? T
    : T extends (infer U)[]
      ? Flatten<U, [...Depth, unknown]>
      : T;
type X = Flatten<number[][]>; // number
const x: X = 7;
console.log(x);

Kedalaman Praktis Biasanya Aman

Tipe rekursif sehari-hari, daftar berantai, pohon, dan JSON hampir tidak pernah mencapai batas karena data yang Anda instansiasi biasanya dangkal. Batas tersebut terutama memengaruhi komputasi tingkat tipe yang berat.

type Json = string | number | boolean | null | Json[] | { [k: string]: Json };
const v: Json = { a: { b: { c: 1 } } }; // fine, shallow
console.log(v);

Mengenali Pesan Kesalahan

Jika Anda melihat "terlalu dalam dan mungkin tak terbatas", carilah kasus dasar yang hilang, akumulator pada posisi non-ekor, atau masukan yang terlalu besar.

// Fixes: add/tighten the base case, switch to tail recursion,
// reduce input size, or cap with a depth counter.
console.log("check base case and tail position");

Rekursi Saat Berjalan Itu Terpisah

Batas ini berkaitan dengan rekursi tingkat tipe. Fungsi rekursif biasa pada tipe rekursif berjalan saat program dijalankan dan hanya dibatasi oleh tumpukan panggilan.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function count<T>(n: TreeNode<T>): number {
  return 1 + n.children.reduce((a, c) => a + count(c), 0);
}
console.log(count({ value: 1, children: [{ value: 2, children: [] }] }));

Merancang dalam Batas

Utamakan data yang dangkal, pola rekursif ekor dengan akumulator, dan batas kedalaman eksplisit. Dengan kebiasaan ini, Anda jarang menemui batas tersebut dalam kode nyata.

type Length<T extends unknown[]> = T["length"];
type N = Length<[1, 2, 3]>; // 3
const n: N = 3;
console.log(n);

Pemeriksaan Singkat: Batas Rekursi

Uji pemahaman Anda tentang kedalaman dan batas rekursi.

Ringkasan: Kedalaman dan Batas Rekursi

Anda mempelajari bahwa TypeScript membatasi kedalaman rekursi tingkat tipe, bahwa pola rekursif ekor dengan akumulator dan batas kedalaman eksplisit dapat membantu, serta bahwa data rekursif sehari-hari jarang mencapai batas tersebut.

type Reverse<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer H, ...infer R] ? Reverse<R, [H, ...Acc]> : Acc;
const r: Reverse<[1, 2]> = [2, 1];
console.log(r);

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Kedalaman dan Batas Rekursi” gratis?

Ya — teks lengkap “Kedalaman dan Batas Rekursi” 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 “Kedalaman dan Batas Rekursi”?

Pahami batasan kedalaman rekursi TypeScript. 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 “Kedalaman dan Batas Rekursi” 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