TypeScript Academy · Pelajaran

Literal Boolean dan Inferensi Literal

Pahami cara TypeScript memperluas atau mempersempit inferensi literal.

Literal Boolean dan Inferensi Literal 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.

Tipe Literal Boolean

Tipe boolean sebenarnya adalah gabungan true | false. Masing-masing merupakan tipe literal boolean: tipe yang hanya mengizinkan satu nilai boolean tertentu.

let yes: true = true;
let no: false = false;
console.log(yes, no);
// yes = false; // Error: false not assignable to true

Literal Boolean dalam Gabungan

Literal boolean sangat berguna saat dipasangkan dengan literal lain untuk memodelkan hasil yang terdiferensiasi, seperti penanda keberhasilan yang digabungkan dengan bentuk muatan data.

type Result =
  | { ok: true; value: number }
  | { ok: false; error: string };

const r: Result = { ok: true, value: 42 };
console.log(r);

Pelebaran Tipe

Saat Anda menginisialisasi variabel, TypeScript menentukan tipe yang harus disimpulkan. Terkadang tipe tersebut mempertahankan literal yang tepat; terkadang tipe itu diperlebar menjadi tipe umum. Memahami hal ini penting untuk memperoleh tipe yang dapat diprediksi.

const exact = 'hello'; // type: 'hello' (literal)
let broad = 'hello';   // type: string (widened)
console.log(exact, broad);

let Diperlebar Menjadi Tipe Umum

Karena variabel let dapat ditetapkan ulang, TypeScript menyimpulkan tipe umum agar penetapan di masa mendatang diizinkan. String let dimulai sebagai string, bukan literal.

let mood = 'happy'; // inferred as string
mood = 'sad';       // allowed
mood = 'tired';     // allowed
console.log(mood);

const Mempertahankan Literal

const tidak pernah dapat ditetapkan ulang, sehingga TypeScript menyimpulkan tipe yang paling spesifik — yaitu literal. Inilah alasan const greeting = 'hi' memiliki tipe 'hi', bukan string.

const greeting = 'hi'; // type: 'hi'

type Greeting = typeof greeting; // 'hi'
const other: Greeting = 'hi';
console.log(other);

Pelebaran dengan Angka dan Boolean

Aturan yang sama berlaku untuk angka dan boolean. const mempertahankan 42 atau true sebagai literal; let memperlebar tipe menjadi number atau boolean.

const n = 42;   // type: 42
const b = true; // type: true
let m = 42;     // type: number
let c = true;   // type: boolean
console.log(n, b, m, c);

Mengapa Pelebaran Tipe Diperlukan

Pelebaran membuat kode sehari-hari tetap praktis. Jika setiap let count = 0 diberi tipe literal 0, Anda tidak dapat menambah nilainya. Pelebaran memungkinkan variabel yang dapat ditetapkan ulang berperilaku secara alami.

let count = 0; // widened to number
count = count + 1;
count = 10;
console.log('Count:', count);

Memaksakan Literal dengan Anotasi

Terkadang Anda ingin let tetap menjadi literal. Tambahkan anotasi tipe literal secara eksplisit, dan TypeScript akan mempertahankan tipe yang sempit tersebut sekaligus tetap memungkinkan penetapan ulang dalam gabungan itu.

let status: 'on' | 'off' = 'on';
status = 'off'; // allowed
console.log(status);
// status = 'paused'; // Error

Pelebaran dalam Properti Objek

Properti literal objek juga diperlebar secara bawaan. Bahkan dalam objek const, properti yang dapat diubah mendapatkan tipe umum karena properti itu sendiri dapat ditetapkan ulang.

const config = { mode: 'dark' };
// config.mode has type string, not 'dark'
config.mode = 'light';
console.log(config.mode);

Inferensi Literal dengan Fungsi

Nilai kembalian fungsi juga disimpulkan. Fungsi yang mengembalikan nilai literal const tetap memperlebar tipe kembalian menjadi tipe umum, kecuali Anda memberi anotasi atau menggunakan tipe literal dalam deklarasi fungsi.

function getMode(): 'dark' | 'light' {
  return 'dark';
}

const m = getMode(); // type: 'dark' | 'light'
console.log(m);

Memilih Tipe Literal atau Umum

Aturan praktisnya: gunakan const atau anotasi literal eksplisit saat Anda memerlukan nilai yang persis (kunci config, diskriminan). Biarkan pelebaran terjadi pada variabel biasa yang dapat diubah. Dengan mengetahui tipe yang akan diperoleh, Anda dapat mencegah kesalahan penetapan tipe yang mengejutkan.

const KEY = 'apiUrl';     // literal 'apiUrl'
let retries = 3;          // number
let level: 'low' | 'high' = 'low'; // pinned literal
console.log(KEY, retries, level);

Pemeriksaan Singkat

Uji pemahaman Anda tentang pelebaran dan inferensi literal.

Ringkasan: Inferensi Literal

Poin penting:

true dan false adalah tipe literal; boolean sama dengan true | false.
let melebar menjadi tipe umum (string, number, boolean).
const mempertahankan tipe literal yang persis.
Beri anotasi dengan tipe literal untuk membatasi let pada gabungan yang sempit.

Selanjutnya, kita menyatakan ketidakberubahan secara eksplisit dengan as const.

const literal = 'fixed'; // 'fixed'
let widened = 'fixed';   // string
let pinned: 'a' | 'b' = 'a';
console.log(literal, widened, pinned);

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Literal Boolean dan Inferensi Literal” gratis?

Ya — teks lengkap “Literal Boolean dan Inferensi Literal” 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 “Literal Boolean dan Inferensi Literal”?

Pahami cara TypeScript memperluas atau mempersempit inferensi literal. 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 “Literal Boolean dan Inferensi Literal” 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