Type Alias di TypeScript: Memberi Nama untuk Tipe Apa Pun

Saat baru kenal TypeScript, kamu bakal sering menulis deskripsi tipe yang sama berulang kali. Di satu tempat seorang user adalah { name: string; email: string }, lalu tiga fungsi kemudian kamu menulis { name: string; email: string } lagi. Cara ini jalan, tapi cepat terasa berantakan, dan begitu kamu perlu menambah satu field saja, kamu harus berburu ke semua salinannya. Type alias menyelesaikan persoalan ini. Dengannya kamu bisa memberi nama pada sebuah tipe — tipe apa pun — lalu memakai nama itu di mana-mana.

Di panduan ini kita akan bahas apa sebenarnya type alias itu, jenis tipe apa saja yang bisa kamu beri nama, dan bagaimana ia dibandingkan dengan kata kunci interface yang mungkin sudah pernah kamu dengar. Setelah selesai, kamu akan tahu mana yang sebaiknya dipakai dan alasannya.

Apa itu type alias

Type alias adalah nama yang kamu tempelkan pada sebuah tipe lewat kata kunci type. Bentuk di sisi kanan tanda = adalah tipe yang sebenarnya; nama di sisi kiri sekadar label praktis untuk tipe itu.

type ID = string;

let userId: ID = "u_1024";

Di sini ID bukan tipe baru yang berdiri sendiri. Ia cuma cara lain untuk menyebut string. Di mana pun kamu bisa menulis string, sekarang kamu bisa menulis ID, dan TypeScript menganggap keduanya sama persis. Keuntungannya ada pada makna: ID memberi tahu pembaca kenapa string ini ada, sedangkan string saja tidak mengatakan apa-apa.

Bagian ini sering terlewat oleh pemula, jadi perlu dijelaskan terang-terangan: alias tidak menciptakan tipe baru saat program berjalan. Setelah kodemu dikompilasi menjadi JavaScript, alias itu hilang sepenuhnya. Ia hanya ada untuk membantu kamu dan pemeriksa tipe selama proses pengembangan.

Memberi nama pada bentuk objek

Pemakaian type alias yang paling umum adalah memberi nama pada bentuk sebuah objek. Daripada mengulang daftar field yang sama, kamu cukup mendeskripsikannya sekali lalu menyebutnya lewat nama.

type User = {
  name: string;
  email: string;
  isActive: boolean;
};

const jane: User = {
  name: "Jane Doe",
  email: "jane@example.com",
  isActive: true,
};

Sekarang User jadi kontrak yang bisa dipakai ulang. Kalau nanti kamu memutuskan setiap user juga butuh field createdAt, kamu cukup mengubah alias di satu tempat dan TypeScript langsung menandai setiap bagian yang tidak lagi cocok. Satu sumber kebenaran inilah inti dari semuanya.

Kamu juga bisa menyusun alias di dalam alias lain, dan ini membuat bentuk yang besar tetap enak dibaca:

type Address = {
  city: string;
  country: string;
};

type Customer = {
  name: string;
  address: Address;
};

Memecah objek besar menjadi potongan-potongan kecil bernama seperti ini membuat tiap bagian gampang dibaca dan dipakai ulang sendiri-sendiri.

Bukan cuma objek: alias untuk primitif dan fungsi

Di sinilah type alias benar-benar menunjukkan nilainya. Sebuah interface hanya bisa mendeskripsikan bentuk yang menyerupai objek, sedangkan type bisa memberi nama pada apa saja — termasuk primitif, fungsi, array, dan tuple.

type Email = string;
type Score = number;

type Greeter = (name: string) => string;

type Point = [number, number];

Greeter memberi nama pada tipe fungsi: fungsi apa pun yang menerima string dan mengembalikan string. Point memberi nama pada tuple — array berisi tepat dua angka. Tidak ada satu pun di sini yang berupa bentuk objek, dan keleluasaan inilah salah satu alasan terkuat memilih type.

Tipe union: fitur paling ampuh

Alasan terbesar orang memakai type alias adalah tipe union. Union berkata “nilai ini boleh berupa salah satu dari beberapa tipe”, dan kamu menuliskannya dengan garis tegak |.

type Status = "pending" | "active" | "banned";

let accountStatus: Status = "active";
// accountStatus = "deleted"; // Error: bukan salah satu nilai yang diizinkan

Status hanya boleh bernilai salah satu dari ketiga string itu. Coba isi dengan yang lain, TypeScript akan menghentikanmu bahkan sebelum kode dijalankan. Pola ini — sekumpulan nilai string tetap yang diizinkan — ada di mana-mana pada aplikasi nyata, mulai dari status pesanan sampai varian tombol.

Union tidak terbatas pada string. Kamu bisa menggabungkan tipe apa pun:

type Id = string | number;

function findUser(id: Id) {
  // id di sini bisa string ATAU number
}

Memberi nama pada union lewat type adalah cara yang paling wajar dan lazim. Pola ini juga menjadi pondasi untuk topik yang lebih lanjut seperti intersection dan discriminated union, yang dibangun langsung dari apa yang baru saja kamu lihat.

Alias Status
  ┌──────────┐
  │ "pending"│ ─┐
  │ "active" │ ─┼─►  satu nilai, harus cocok persis satu pilihan
  │ "banned" │ ─┘
  └──────────┘

Type alias vs interface

Kalau pernah membaca tutorial TypeScript, kamu mungkin sudah ketemu interface juga. Untuk mendeskripsikan sebuah objek, keduanya terlihat hampir sama:

type UserA = {
  name: string;
  email: string;
};

interface UserB {
  name: string;
  email: string;
}

Keduanya jalan, dan untuk bentuk objek biasa kamu boleh memakai yang mana saja. Perbedaannya muncul di hal-hal pinggiran. Berikut perbandingan praktisnya:

Satu trik yang benar-benar khas dari interface adalah declaration merging: kalau kamu mendeklarasikan nama interface yang sama dua kali, TypeScript menggabungkannya jadi satu. Kedengarannya aneh, tapi ini berguna untuk memperluas tipe dari pustaka eksternal. Alias type tidak bisa dibuka ulang seperti itu — deklarasikan nama yang sama dua kali, dan kamu akan mendapat error.

Menggabungkan beberapa tipe

Karena alias bisa memberi nama pada union, ia juga bisa digabungkan. Operator & membuat intersection — tipe yang harus memenuhi semua bagian sekaligus.

type Timestamps = {
  createdAt: string;
  updatedAt: string;
};

type Article = {
  title: string;
  body: string;
} & Timestamps;

Sebuah Article sekarang butuh title, body, createdAt, dan updatedAt — field dari kedua bentuk yang digabung jadi satu. Ini padanan type untuk interface ... extends, dan jadi cara rapi untuk berbagi field umum antarbanyak bentuk tanpa harus mengulang-ulang.

Beberapa kesalahan yang sering terjadi

Ada beberapa jebakan kecil yang sering menjerat pemula. Pertama, ingat bahwa memberi alias pada primitif tidak membuatnya jadi tipe yang berbeda. type Email = string dan type Score = number keduanya tetap kembali ke primitif aslinya, jadi TypeScript akan dengan santai membiarkanmu menaruh Email di tempat yang minta string biasa, begitu pula sebaliknya. Alias menambah keterbacaan, bukan pengaman tambahan agar tidak tertukar.

Kedua, jangan menyamakan type alias dengan variabel. Ia hidup di dunia tipe, bukan dunia nilai, jadi tidak bisa dipakai di tempat yang membutuhkan nilai saat runtime:

type Status = "active" | "banned";

console.log(Status); // Error: 'Status' hanya merujuk ke tipe, bukan nilai

Rangkuman

Type alias termasuk perkakas sehari-hari yang paling berguna di TypeScript. Inilah hal-hal yang perlu kamu bawa pulang:

• Kata kunci type memberi nama pada tipe apa pun — primitif, bentuk objek, fungsi, tuple, dan union — bukan cuma objek.
• Memberi nama pada bentuk objek memberimu satu sumber kebenaran yang bisa dipakai ulang dan diubah di satu tempat saja.
• Union yang ditulis dengan | adalah pemakaian yang paling menonjol, pas untuk sekumpulan nilai tetap yang diizinkan seperti status.
• Alias dihapus saat kompilasi, jadi tidak memakan biaya saat runtime dan bukan nilai nyata yang bisa dipakai di dalam kode.
• Pakai type untuk union, tipe fungsi, dan apa pun yang bukan objek; pakai interface untuk kontrak objek yang mungkin ingin kamu perluas atau gabung.

Dengan alias di genggaman, kamu siap menyelam lebih dalam ke union dan intersection, di mana memberi nama tipe menjadi batu bangunan untuk mendeskripsikan data nyata yang bercabang dengan percaya diri.