Tipe Dasar & Type Inference

Tipe primitif (string, number, boolean, bigint), template literal, kapan menulis tipe sendiri dan kapan membiarkan TypeScript menebak (inference), serta perbedaan let dan const.

Part 2 dari 24 ± 40 menit Gratis

Tipe primitif

Primitif adalah tipe paling dasar — nilai tunggal, bukan kumpulan. TypeScript punya padanan untuk semua primitif JavaScript:

TipeIsiContoh
stringTeks"halo", 'dunia', `x = ${x}`
numberAngka (bulat maupun desimal)42, 3.14, -7, NaN
booleanBenar / salahtrue, false
bigintBilangan bulat sangat besar9007199254740993n
symbolPengenal unik (jarang dipakai)Symbol("id")

Tulis string, number, boolean dengan huruf kecil. Versi huruf besar (String, Number) adalah objek pembungkus JavaScript dan hampir tidak pernah yang kamu inginkan.

Anotasi tipe

let judul: string = "Belajar TS"
let harga: number = 49000
let diskon: boolean = false

judul = 123        // ❌ Type 'number' is not assignable to type 'string'
harga = "murah"    // ❌ Type 'string' is not assignable to type 'number'

Begitu tipe ditetapkan, variabel itu terkunci: nilai berikutnya harus bertipe sama. Inilah inti proteksi TypeScript.

Type inference: TypeScript bisa menebak

Kamu tidak wajib menulis tipe di mana-mana. Jika variabel langsung diberi nilai, TypeScript menyimpulkan tipenya sendiri:

let kota = "Bandung"     // disimpulkan: string
let stok = 12            // disimpulkan: number
let tersedia = true      // disimpulkan: boolean

kota = 99                // ❌ tetap error, walau kita tidak menulis ": string"

Arahkan kursor ke nama variabel di editor — kamu akan melihat tipe hasil tebakan itu.

Kapan menulis tipe, kapan membiarkan inference?

SituasiSaran
Variabel langsung diberi nilaiBiarkan inference (const umur = 21)
Variabel dideklarasikan dulu, diisi nantiTulis tipe (let nama: string)
Parameter fungsiSelalu tulis tipe
Tipe kembalian fungsiBoleh dibiarkan, tapi menulisnya membuat niat lebih jelas dan menangkap kesalahan lebih dini
Nilai awal kosong ([], null)Tulis tipe agar tidak menjadi never[] / null

let vs const: tipe literal

Perhatikan perbedaan halus ini — const mengunci nilai, sehingga tipenya menjadi nilai itu sendiri (disebut literal type):

let a = "merah"      // tipe: string        (boleh diganti teks apa saja)
const b = "merah"    // tipe: "merah"        (hanya boleh "merah")

Literal type dipakai luas di bab 5. Untuk sekarang cukup ingat: const → tipe yang lebih sempit.

Template literal dan operasi dasar

const nama: string = "Rina"
const umur: number = 25
const kalimat: string = `${nama} berumur ${umur} tahun`   // template literal
const panjang: number = nama.length                         // 4
const besar: string = nama.toUpperCase()                    // "RINA"

TypeScript tahu bahwa nama adalah string, jadi autocomplete menawarkan semua metode string (toUpperCase, slice, ...) dan menolak metode angka seperti nama.toFixed(2).

Mengabaikan error sementara: @ts-expect-error

Untuk demonstrasi atau pengujian, komentar khusus ini menandai bahwa baris berikutnya memang error. Jika ternyata tidak error, TypeScript justru protes — jadi aman dipakai.

// @ts-expect-error — sengaja salah untuk contoh
const x: number = "bukan angka"

Kesalahan umum pemula

  • Menulis String/Number berhuruf besar sebagai tipe.
  • Menulis tipe berlebihan: const n: number = 5 sah, tapi const n = 5 sudah cukup.
  • Lupa bahwa let x; tanpa tipe dan tanpa nilai awal bertipe any — hindari.

Praktikkan langsung, gratis

Tulis dan jalankan kode langsung di browser, dapatkan penilaian otomatis. Daftar gratis kapan saja untuk menyimpan progres dan meraih sertifikat.

Coba latihan sekarang, tanpa daftar
Bagikan: WhatsApp Facebook LinkedIn X