TypeScript Academy · Pelajaran

Jenis sebagai Bahasa Komputasi

Pahami sistem jenis sebagai bahasa fungsional murni.

Jenis sebagai Bahasa Komputasi 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.

Tipe adalah Sebuah Bahasa

TypeScript memiliki dua bahasa yang hidup berdampingan. Salah satunya adalah JavaScript tingkat nilai yang sudah Anda kenal. Yang lainnya adalah tingkat tipe, yang berjalan sepenuhnya saat kompilasi. Dalam kursus ini, Anda belajar memprogram dalam bahasa kedua tersebut.

Sistem tipe adalah bahasa fungsional murni yang kecil. Anda memberinya tipe sebagai masukan, lalu sistem tersebut menghitung tipe sebagai keluaran. Tidak ada bagian dari proses ini yang bertahan hingga waktu eksekusi.

type Greeting = "hello";
type Loud = Uppercase<Greeting>;
// Loud is "HELLO" - computed by the type system

Tipe Masuk, Tipe Keluar

Tipe generik pada dasarnya adalah fungsi dari tipe ke tipe. Parameter tipe adalah argumennya, sedangkan isi fungsi adalah nilai pengembaliannya.

Di bawah ini, Boxed menerima sebuah tipe T dan menghasilkan tipe objek yang membungkusnya. Anggaplah T sebagai parameter yang Anda masukkan.

type Boxed<T> = { value: T };

type A = Boxed<number>; // { value: number }
type B = Boxed<string>; // { value: string }

Generik adalah Fungsi

Bandingkan fungsi tingkat nilai dengan fungsi tingkat tipe. Strukturnya hampir identik: parameter masuk dan satu hasil keluar.

Nilai: const id = (x) => x
Tipe: type Id<T> = T

Id tingkat tipe cukup mengembalikan apa pun yang Anda berikan.

type Id<T> = T;

type X = Id<boolean>; // boolean
type Y = Id<"abc">;  // "abc"

Tidak Ada Biaya Waktu Eksekusi

Semua hal pada tingkat tipe dihapus sebelum kode Anda dijalankan. Keluaran JavaScript tidak mengandung jejak apa pun dari perhitungan tipe Anda. Tidak ada biaya kinerja dalam program yang berjalan, betapa pun rumitnya tipe Anda.

Inilah alasan pemrograman tingkat tipe terkadang disebut gratis: pemrograman ini hanya memengaruhi kompiler, tidak pernah memengaruhi bundel.

type Pair<T> = [T, T];
const p: Pair<number> = [1, 2];
// Compiled JS is just: const p = [1, 2];
console.log(p);

Beberapa Parameter

Fungsi tingkat tipe dapat menerima beberapa parameter, sama seperti fungsi biasa. Di sini Merge menerima dua tipe objek dan menggabungkannya.

Bacalah sebagai berikut: dengan diberikan A dan B, kembalikan sebuah objek yang memiliki semua properti dari keduanya.

type Merge<A, B> = A & B;

type User = { id: number };
type Named = { name: string };
type NamedUser = Merge<User, Named>;
// { id: number; name: string }

Nilai Bawaan untuk Parameter

Parameter tipe dapat memiliki nilai bawaan, sama seperti argumen fungsi bawaan. Jika pemanggil tidak memberikan argumen, nilai bawaan akan digunakan.

type List<T = string> = T[];

type A = List;        // string[]
type B = List<number>; // number[]

Batasan Adalah Pengaman

Batasan dengan extends membatasi tipe yang boleh diberikan. Batasan ini setara pada tingkat tipe dengan memvalidasi argumen fungsi sebelum menggunakannya.

HasId hanya menerima tipe yang sudah memiliki properti id, sehingga isi fungsi dapat membacanya dengan aman.

type GetId<T extends { id: number }> = T["id"];

type A = GetId<{ id: number; name: string }>; // number
// GetId<{ name: string }> would be a compile error

Perhitungan, Bukan Sekadar Anotasi

Pemula menggunakan tipe hanya untuk melabeli nilai. Pemrograman pada tingkat tipe menggunakan tipe untuk menghitung hasil. Utilitas bawaan ReturnType, misalnya, memeriksa tipe fungsi dan mengekstrak tipe hasilnya.

type Fn = (a: number) => string;
type R = ReturnType<Fn>; // string

type Fn2 = () => boolean;
type R2 = ReturnType<Fn2>; // boolean

Memetakan Properti

Tipe pemetaan memungkinkan Anda mengubah setiap properti dari tipe objek. Ini adalah perulangan dalam bahasa tipe. Stringify mengubah setiap tipe nilai menjadi string.

type Stringify<T> = { [K in keyof T]: string };

type Input = { a: number; b: boolean };
type Out = Stringify<Input>; // { a: string; b: string }

Murni dan Deterministik

Bahasa tipe bersifat murni: masukan yang sama selalu menghasilkan tipe keluaran yang sama, tanpa efek samping. Tidak ada mutasi, tidak ada IO, dan tidak ada waktu. Kemurnian inilah yang membuat program pada tingkat tipe dapat diprediksi dan digabungkan.

Karena bersifat murni, Anda menalar tentang tipe seperti saat menalar tentang matematika: melalui substitusi.

type Square<T extends { area: number }> = T["area"];
// Always the same result for the same input shape

Mengapa Ini Penting

Menguasai bahasa kedua ini memungkinkan Anda menyandikan aturan yang diberlakukan kompilator secara gratis: rute yang valid, percabangan switch yang mencakup semua kemungkinan, manipulasi teks yang aman, dan API yang tidak dapat digunakan secara keliru. Bagian selanjutnya dari kursus ini akan membangun perangkatnya.

Pola pikir utama: tipe adalah nilai dalam bahasa tipe, dan generik adalah fungsi.

type NonEmpty<T extends unknown[]> =
  T extends [unknown, ...unknown[]] ? T : never;
// Encodes a rule: the tuple must have at least one element

Pemeriksaan Singkat

Uji pemahaman Anda tentang tipe sebagai bahasa perhitungan.

Rangkuman

Anda telah mempelajari bahwa tipe TypeScript membentuk bahasa fungsional murni yang berjalan pada waktu kompilasi.

Generik adalah fungsi: tipe masuk, tipe keluar.
Parameter mendukung nilai bawaan dan batasan extends.
Tipe pemetaan melakukan perulangan pada properti.
Semuanya dihapus, sehingga tidak ada biaya saat program berjalan.

Berikutnya, Anda akan memberikan bahasa ini pernyataan kondisional: tipe kondisional.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Jenis sebagai Bahasa Komputasi” gratis?

Ya — teks lengkap “Jenis sebagai Bahasa Komputasi” 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 “Jenis sebagai Bahasa Komputasi”?

Pahami sistem jenis sebagai bahasa fungsional murni. 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 “Jenis sebagai Bahasa Komputasi” 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