Belajar TypeScript - Tipe Primitif dan Tipe Struktur Dasar

#Pendahuluan

Setelah environment siap, kita mulai dengan fondasi paling penting: tipe primitif. Semua sistem tipe TypeScript, sekalipun yang paling rumit, dibangun dari blok dasar ini. Kalau episode 0 adalah setup lingkungan, episode 3 adalah setup mental tentang bagaimana tipe bekerja.

Kalian mungkin berpikir topik ini membosankan karena terlihat sederhana. Justru sebaliknya: banyak bug di production berasal dari salah memahami perilaku null dan undefined, atau dari any yang dipakai berlebihan sehingga seluruh jaminan tipe runtuh.

Episode 3 membedah setiap tipe primitif, tipe khusus untuk keadaan yang tidak pasti, serta perbedaan annotation (menulis tipe eksplisit) dan inference (membiarkan compiler menebak).

#Tipe Primitif

#string, number, dan boolean

Tiga tipe yang paling sering dipakai:

let nama: string = "Arman";
let umur: number = 30;
let aktif: boolean = true;
 
let harga: number = 4999.99;
let kalimat: string = `Total: ${harga}`;
let sudahBayar: boolean = false;

Deklarasi let umur: number = 30; menandai variabel umur hanya boleh diisi angka. TypeScript tidak membedakan bilangan bulat dan pecahan — semuanya number. Template literal di atas tetap berjenis string.

#bigint, symbol, null, dan undefined

Empat primitif lain yang lebih jarang:

• bigint untuk bilangan bulat yang sangat besar, ditulis dengan akhiran n.
• symbol untuk nilai unik, biasanya dipakai sebagai kunci properti objek.
• null untuk nilai yang sengaja dikosongkan.
• undefined untuk variabel yang belum diinisialisasi.

let akunBesar: bigint = 9007199254740993n;
let tombol = Symbol("unik");
 
let kosong: null = null;
let belumDitetapkan: undefined = undefined;

#Tipe Khusus untuk Keadaan Tidak Pasti

#any dan unknown

any adalah tipe yang menonaktifkan seluruh pemeriksaan — nilai boleh diisi apa saja dan dipakai dengan cara apa saja. Kadang berguna saat migrasi (episode 13), tapi di luar itu ia merusak semua jaminan tipe.

let dataLonggar: any = "bebas";
dataLonggar.jalanSaja();
 
let dataTakPasti: unknown = "bisa apa saja";
if (typeof dataTakPasti === "string") {
    console.log(dataTakPasti.toUpperCase());
}

Perhatikan unknown: aman karena harus dipersempit dulu sebelum dipakai. unknown adalah saudara yang bertanggung jawab dari any.

#void dan never

• void menandai fungsi yang tidak mengembalikan nilai berarti.
• never menandai nilai yang tidak akan pernah ada — fungsi yang selalu melempar error atau loop tanpa akhir.

function catat(log: string): void {
    console.log(log);
}
 
function gagal(pesan: string): never {
    throw new Error(pesan);
}

Fungsi gagal(pesan: string): never tidak akan pernah mengembalikan kontrol ke pemanggil, jadi tipenya never, bukan void.

#Type Annotation vs Type Inference

Kalian tidak selalu harus menulis tipe secara eksplisit:

const harga = 4999;          // tipe number disimpulkan
const judul = "Pelajaran";   // tipe string disimpulkan
let mode: "gelap" | "terang" = "gelap";

Compiler menyimpulkan harga bertipe number langsung dari nilai inisialnya. Inference ini membuat kode tetap ringkas tanpa kehilangan keamanan. Annotation baru wajib saat tipe tidak bisa disimpulkan, atau saat kalian ingin tipe yang lebih spesifik dari nilai inisial.

#null dan undefined dengan strictNullChecks

#Perilaku Saat Mode Ketat Aktif

Dengan strict: true, opsi strictNullChecks aktif: null dan undefined tidak bisa dimasukkan ke variabel bertipe biasa. Ini perubahan paling berdampak bagi developer yang baru pindah dari JavaScript.

let nama: string = "Arman";
nama = null; // error: null tidak cocok dengan string

Error seperti ini memaksa kalian menangani kasus kosong secara eksplisit — dengan union string | null, guard typeof, atau nilai default. Di episode 4 dan 11 kita akan membahas pola menanganinya.

#Penutup

Episode 3 memberi kalian alfabet sistem tipe: primitif seperti string dan number, tipe khusus any, unknown, void, dan never, serta pemahaman kapan menulis annotation dan kapan mengandalkan inference. Kalian juga tahu cara kerja strictNullChecks.

Inti yang harus dibawa pulang:

• Primitif utama: string, number, boolean, plus bigint, symbol, null, undefined.
• any menonaktifkan pemeriksaan; unknown aman karena harus dipersempit dulu.
• void untuk fungsi tanpa nilai; never untuk yang tidak pernah selesai.
• Inference menyimpulkan tipe dari nilai inisial; annotation memberi tipe eksplisit.
• strictNullChecks mencegah null dan undefined masuk tanpa disadari.
• Semakin sedikit any, semakin kuat jaminan tipe kalian.

Di episode 4 selanjutnya kita akan membahas union, intersection, dan tipe literal — menggabungkan tipe dengan | dan &, serta mengunci nilai ke literal tertentu. Ini alat pertama untuk memodelkan data nyata yang bentuknya beragam.