0Pricing
TypeScript Academy · Pelajaran

Menghindari Operasi Tipe yang Mahal

Identifikasi dan perbaiki tipe yang sangat rekursif atau distributif.

Menghindari Operasi Tipe yang Mahal adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 2 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 yang Membuat Operasi Tipe Menjadi Mahal?

Tipe yang sangat rekursif, distribusi gabungan besar, dan rantai inferensi yang kompleks memaksa TypeScript membuat banyak variasi tipe, sehingga menyebabkan perlambatan eksponensial.

// Expensive: distributes over every member of a large union
type FilterStrings<T> = T extends string ? T : never;
type Result = FilterStrings<string | number | boolean | null | undefined | ...>;

Hindari Ukuran Gabungan yang Berlebihan

Gabungan dengan ratusan anggota (misalnya, dari banyak literal string) dapat membuat pemeriksaan tipe menjadi sangat lambat. Pertimbangkan untuk mempersempit domain atau menggunakan string dengan validasi.

// Expensive
type HugeUnion = "a" | "b" | "c" | /* 200 more ... */ "z";
// Better: string with a runtime check
function isValid(s: string): s is ValidString { return VALID_SET.has(s); }

Utamakan Interface daripada Alias Tipe yang Kompleks

TypeScript melakukan cache pada interface secara lebih agresif daripada irisan alias tipe yang kompleks. Utamakan interface untuk bentuk objek yang sering dirujuk.

// Slow: recomputed union intersection each time
type BigObject = TypeA & TypeB & TypeC & TypeD;
// Fast: interface (cached)
interface BigObject extends TypeA, TypeB, TypeC, TypeD {}

Batasi Kedalaman Rekursi

Tipe kondisional rekursif sangat kuat, tetapi dapat mencapai batas kedalaman TypeScript (biasanya 100 tingkat). Tambahkan penghitung kedalaman agar proses berhenti lebih awal.

type Flatten<T, Depth extends number[] = []> =
  Depth["length"] extends 10 ? T
  : T extends (infer U)[] ? Flatten<U, [...Depth, 0]>
  : T;

Lakukan Cache pada Tipe Perantara

Beri nama pada tipe perantara yang kompleks agar TypeScript dapat menyimpan dan menggunakannya kembali, alih-alih menghitung ulang pada setiap referensi.

// Before: recomputed at each use
type MyResult<T> = T extends SomeComplex<infer U> ? Transform<U> : never;

// After: split into named intermediates
type ExtractU<T> = T extends SomeComplex<infer U> ? U : never;
type MyResult<T> = Transform<ExtractU<T>>;

Hindari Tipe Terpetakan Mendalam pada Objek Besar

Menerapkan DeepReadonly pada tipe objek yang sangat besar menyebabkan TypeScript menelusuri setiap properti secara rekursif, sehingga membutuhkan banyak sumber daya.

// Expensive on 50-property nested objects
type Safe = DeepReadonly<HugeConfig>;
// Better: annotate at creation time with const assertions

Gunakan Evaluasi Generik Malas

Membungkus tipe mahal dalam thunk (tipe fungsi yang mengembalikan tipe tersebut) menunda evaluasi sampai tipe itu benar-benar diperlukan.

// Lazy evaluation via wrapper
type Lazy<T> = () => T;
type ExpensiveLazy = Lazy<DeepReadonly<HugeConfig>>;

Utamakan Tipe Kembalian Eksplisit

Memberi anotasi secara eksplisit pada tipe kembalian fungsi mencegah TypeScript menginferensikannya berulang kali di setiap lokasi pemanggilan, sehingga mempercepat pemeriksaan tipe.

// Let TypeScript infer (may be slow for complex functions)
function process(data: Input) { return transform(data); }

// Faster: explicit annotation
function process(data: Input): Output { return transform(data); }

isolatedDeclarations untuk Pemeriksaan Paralel

isolatedDeclarations pada TypeScript 5.5+ mengharuskan tipe kembalian eksplisit, sehingga memungkinkan pemeriksaan tipe secara paralel pada berkas yang tidak saling bergantung tanpa inferensi penuh.

// tsconfig.json
{
  "compilerOptions": {
    "isolatedDeclarations": true
  }
}

Referensi Proyek untuk Isolasi

Referensi proyek mencegah TypeScript memeriksa tipe paket yang tidak berubah, yang merupakan peningkatan terbesar untuk monorepo besar.

# With project references:
# tsc --build only recompiles packages whose sources changed
# Unchanged packages: declaration files used directly

Rangkuman: Menghindari Tipe Mahal

Agar TypeScript tetap cepat: hindari gabungan yang sangat besar, lakukan cache pada tipe perantara, utamakan interface daripada alias yang kompleks, batasi kedalaman rekursi, gunakan tipe kembalian eksplisit, dan isolasikan paket dengan referensi proyek.

Pemeriksaan Singkat

Pendekatan mana yang membantu TypeScript melakukan cache pada bentuk objek secara lebih agresif?

Yang Anda Pelajari

Operasi tipe TypeScript yang mahal mencakup gabungan besar, rekursi mendalam, dan inferensi kompleks yang berulang. Optimalkan dengan melakukan cache pada tipe perantara, mengutamakan interface, membatasi ukuran gabungan, dan menggunakan referensi proyek untuk monorepo.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menghindari Operasi Tipe yang Mahal” gratis?

Ya — teks lengkap “Menghindari Operasi Tipe yang Mahal” 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 “Menghindari Operasi Tipe yang Mahal”?

Identifikasi dan perbaiki tipe yang sangat rekursif atau distributif. 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 2 dari 4.

Berapa lama pelajaran “Menghindari Operasi Tipe yang Mahal” 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. Membuat Profil Kompilasi TypeScript yang Lambat
  2. Menghindari Operasi Tipe yang Mahal
  3. skipLibCheck dan Deklarasi Terisolasi
  4. Pemeriksaan Tipe di CI: Strategi dan Alat
← Kembali ke TypeScript Academy