TypeScript Academy · Pelajaran

Definisi Jenis Rekursif

Tulis jenis yang merujuk pada dirinya sendiri dengan aman.

Definisi Jenis Rekursif adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 1 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.

Apa Itu Tipe Rekursif?

Tipe rekursif adalah tipe yang merujuk pada dirinya sendiri dalam definisinya. Dengan demikian, Anda dapat mendeskripsikan struktur data dengan kedalaman tak terbatas.

type LinkedList<T> = {
  value: T;
  next: LinkedList<T> | null;
};
// next is the same type again, ending at null.

Tipe Daftar Tertaut

Contoh klasiknya: setiap simpul menyimpan value dan penunjuk next ke simpul lain, atau null untuk mengakhiri chain.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const list: LinkedList<number> = {
  value: 1,
  next: { value: 2, next: null }
};
console.log(list.value, list.next?.value);

Kasus Dasar Itu Penting

Setiap tipe rekursif memerlukan penghenti, dalam hal ini null, agar rekursinya dapat berakhir. Tanpanya, tipe tersebut akan memiliki kedalaman tak terhingga.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const single: LinkedList<string> = { value: "only", next: null };
console.log(single.next);

Membangun Chain yang Lebih Panjang

Anda dapat melakukan penyusunan bertingkat sedalam yang diinginkan; tipe ini mengizinkan panjang apa pun karena next sendiri merupakan daftar atau null.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const chain: LinkedList<number> = {
  value: 10,
  next: { value: 20, next: { value: 30, next: null } }
};
console.log(chain.next?.next?.value);

Menelusuri Daftar Tertaut

Suatu fungsi dapat menelusuri chain dengan mengikuti next hingga mencapai null. Tipe rekursif membuat proses ini sepenuhnya aman secara tipe.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function toArray<T>(list: LinkedList<T> | null): T[] {
  const out: T[] = [];
  let cur = list;
  while (cur) { out.push(cur.value); cur = cur.next; }
  return out;
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(toArray(l));

Fungsi Rekursif pada Tipe Rekursif

Tipe rekursif berpadu secara alami dengan fungsi rekursif. Di sini, kita menghitung panjang dengan melakukan rekursi pada next.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function length<T>(list: LinkedList<T> | null): number {
  return list === null ? 0 : 1 + length(list.next);
}
const l: LinkedList<string> = { value: "a", next: { value: "b", next: null } };
console.log(length(l));

Menambahkan Elemen ke Awal Daftar

Karena tipenya seragam, membuat daftar baru menjadi mudah: bungkus daftar yang sudah ada sebagai next dari simpul kepala baru.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function prepend<T>(value: T, list: LinkedList<T> | null): LinkedList<T> {
  return { value, next: list };
}
const l = prepend(1, prepend(2, null));
console.log(l.value, l.next?.value);

Penghenti Opsional vs Dapat Bernilai Null

Anda dapat mengakhiri dengan null atau menjadikan next opsional. Keduanya mengakhiri rekursi; pilih berdasarkan cara Anda ingin merepresentasikan akhir daftar.

type ListA<T> = { value: T; next: ListA<T> | null };
type ListB<T> = { value: T; next?: ListB<T> };
const a: ListA<number> = { value: 1, next: null };
const b: ListB<number> = { value: 1 };
console.log(a.value, b.value);

Tipe Rekursif Diekspansi Sesuai Kebutuhan

TypeScript hanya memperluas tipe rekursif sejauh yang benar-benar Anda gunakan. Definisinya dapat merujuk pada dirinya sendiri tanpa menyebabkan pekerjaan tak terhingga.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
// Using two levels only expands two levels.
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(l.next?.value);

Memetakan Daftar

Pemetaan rekursif mengubah setiap nilai sambil mempertahankan strukturnya, lalu mengembalikan daftar baru dengan bentuk yang sama.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function mapList<T, U>(list: LinkedList<T> | null, fn: (v: T) => U): LinkedList<U> | null {
  if (list === null) return null;
  return { value: fn(list.value), next: mapList(list.next, fn) };
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(mapList(l, x => x * 10)?.value);

Mengapa Tipe Rekursif Sangat Kuat

Tipe yang merujuk pada dirinya sendiri memungkinkan Anda memodelkan data bertingkat dengan kedalaman tak terbatas, daftar, pohon, dan JSON, dengan keamanan tipe penuh serta tanpa batas kedalaman tetap dalam desain Anda.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<boolean> = { value: true, next: { value: false, next: null } };
console.log(l.value, l.next?.value);

Pemeriksaan Singkat: Tipe Rekursif

Uji pemahaman Anda tentang definisi tipe rekursif.

Ringkasan: Definisi Tipe Rekursif

Anda telah mempelajari bahwa tipe rekursif merujuk pada dirinya sendiri, memerlukan kasus dasar seperti null untuk berhenti, dan berpadu secara alami dengan fungsi rekursif untuk menelusuri, memetakan, serta membangun daftar tertaut.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<number> = { value: 1, next: null };
console.log(l.value);

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Definisi Jenis Rekursif” gratis?

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

Tulis jenis yang merujuk pada dirinya sendiri dengan aman. 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 1 dari 4.

Berapa lama pelajaran “Definisi Jenis Rekursif” 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