TypeScript - Enums: A Panduan untuk Pemula

Hai, para pemrogram masa depan! Hari ini, kita akan melihat dunia yang menakjubkan dari TypeScript Enums. Jangan khawatir jika Anda belum pernah mengoding sebelumnya - saya akan menjadi panduan yang ramah untuk Anda dalam perjalanan ini, seperti yang saya lakukan untuk ribuan murid selama tahun-tahun mengajar saya. mari kita mulai!

TypeScript - Enums

Apa Itu Enums?

Sebelum kita melompat ke jenis Enums yang berbeda, mari kita pahami apa itu Enums. Bayangkan Anda sedang mengatur lemari pakaian Anda. Anda mungkin memiliki kategori yang berbeda untuk pakaian Anda: kaos, celana, sepatu, dll. Enums di TypeScript seperti kategori ini - mereka membantu kita mengelompokkan nilai yang terkait bersama-sama dan memberikan mereka nama yang berarti.

Enums Numerik

Enums Numerik adalah jenis Enums yang paling umum di TypeScript. Mereka seperti memberikan nomor kepada superhero kesukaan Anda.

enum Superheroes {
Superman,
Batman,
WonderWoman,
Flash
}

console.log(Superheroes.Superman);  // Output: 0
console.log(Superheroes.Batman);    // Output: 1
console.log(Superheroes.WonderWoman);  // Output: 2
console.log(Superheroes.Flash);     // Output: 3

Dalam contoh ini, TypeScript secara otomatis memberikan nomor mulai dari 0. Superman mendapat 0, Batman mendapat 1, dan seterusnya. Itu seperti mereka mengatur untuk foto kelompok, dan kita memberikan mereka nomor berdasarkan posisi mereka!

Tapi apa bila kita ingin memulai dengan nomor yang berbeda? Tidak masalah! Kita bisa melakukan itu juga:

enum Villains {
Joker = 1,
LexLuthor,
Cheetah,
ReverseFlash
}

console.log(Villains.Joker);        // Output: 1
console.log(Villains.LexLuthor);    // Output: 2
console.log(Villains.Cheetah);      // Output: 3
console.log(Villains.ReverseFlash); // Output: 4

Di sini, kita mengatakan kepada TypeScript untuk mulai menghitung dari 1 untuk Joker, dan secara otomatis melanjutkan untuk sisanya.

Enums String

Sekarang, katakanlah Anda tidak suka nomor dan lebih memilih kata. Itu di mana Enums String berguna. Mereka seperti memberikan nama panggilan kepada hewan peliharaan Anda!

enum PetNames {
Dog = "BUDDY",
Cat = "WHISKERS",
Fish = "BUBBLES",
Bird = "TWEETY"
}

console.log(PetNames.Dog);   // Output: "BUDDY"
console.log(PetNames.Cat);   // Output: "WHISKERS"
console.log(PetNames.Fish);  // Output: "BUBBLES"
console.log(PetNames.Bird);  // Output: "TWEETY"

Dengan Enums String, kita harus memberikan nilai ke setiap anggota. Itu seperti memastikan setiap hewan peliharaan Anda mengetahui nama panggilannya yang khusus!

Enums Heterogen

kadang-kadang, kehidupan tidak hanya tentang nomor atau hanya tentang string - itu adalah campuran! Enums Heterogen seperti kotak cokelat berbagai jenis - Anda mendapat sedikit dari segala sesuatu.

enum MixedBag {
Number = 1,
String = "STRING",
AnotherNumber = 2
}

console.log(MixedBag.Number);        // Output: 1
console.log(MixedBag.String);        // Output: "STRING"
console.log(MixedBag.AnotherNumber); // Output: 2

Meskipun ini dimungkinkan, biasanya disarankan untuk tetap menggunakan baik semua nomor atau semua string di Enums untuk konsistensi.

Enums di Waktu Eksekusi

Salah satu hal menarik tentang Enums adalah mereka ada di waktu eksekusi. Ini berarti Anda dapat menggunakannya di kode Anda seperti objek lainnya!

enum Fruits {
Apple,
Banana,
Orange
}

function getFruitName(fruit: Fruits): string {
return Fruits[fruit];
}

console.log(getFruitName(Fruits.Apple));  // Output: "Apple"
console.log(getFruitName(Fruits.Banana)); // Output: "Banana"

Di sini, kita menggunakan Enums seperti objek biasa. Itu seperti memiliki kamus magis yang dapat menerjemahkan nomor ke nama buah!

Enums di Waktu Kompilasi

Enums juga menonjol di waktu kompilasi. Mereka membantu TypeScript menangkap kesalahan sebelum kode Anda bahkan dijalankan!

enum DaysOfWeek {
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
}

let day: DaysOfWeek = DaysOfWeek.Monday;
day = DaysOfWeek.Friday;  // Ini baik

// day = "Monday";  // Kesalahan: Tipe '"Monday"' tidak dapat diassign ke tipe 'DaysOfWeek'.

TypeScript akan memberikan Anda kesalahan jika Anda mencoba mengassign nilai yang bukan bagian dari Enums. Itu seperti memiliki penjaga keras di klub yang hanya membolehkan hari dalam minggu masuk!

Enums Ambien

Enums Ambien adalah sedikit spesial. Mereka digunakan saat Anda memberitahu TypeScript tentang Enums yang ada di tempat lain dalam kode Anda atau di dalam pustaka yang Anda gunakan.

declare enum ExternalEnum {
A = 1,
B,
C = 2
}

Kata kunci declare seperti mengatakan, "Hey TypeScript, percayalah, Enums ini ada di tempat lain dalam kode." Itu berguna saat Anda bekerja dengan kode yang tidak ditulis dalam TypeScript.

Objek vs. Enums

Anda mungkin berpikir, "Mengapa tidak hanya menggunakan objek?" Well, Enums memiliki beberapa keunggulan:

// Menggunakan objek
const ColorObject = {
Red: 'RED',
Green: 'GREEN',
Blue: 'BLUE'
} as const;

// Menggunakan Enums
enum ColorEnum {
Red = 'RED',
Green = 'GREEN',
Blue = 'BLUE'
}

// Dengan objek, Anda perlu menggunakan penegasan tipe
let objColor: keyof typeof ColorObject = 'Red';

// Dengan Enums, itu lebih mudah
let enumColor: ColorEnum = ColorEnum.Red;

Enums menyediakan keamanan tipe yang lebih baik dan lebih ringkas dalam banyak kasus.

Menggunakan Enums sebagai Parameter Fungsi

Enums sangat cocok untuk parameter fungsi. Mereka membuat kode Anda lebih mudah dibaca dan mencegah kesalahan:

enum Sizes {
Small,
Medium,
Large
}

function orderCoffee(size: Sizes): string {
switch(size) {
case Sizes.Small:
return "Here's your small coffee!";
case Sizes.Medium:
return "One medium coffee coming right up!";
case Sizes.Large:
return "Large coffee, extra caffeine!";
default:
return "We don't have that size!";
}
}

console.log(orderCoffee(Sizes.Medium));  // Output: "One medium coffee coming right up!"
// console.log(orderCoffee("Venti"));    // Kesalahan: Argumen tipe '"Venti"' tidak dapat diassign ke parameter tipe 'Sizes'.

Dengan menggunakan Enums untuk parameter ukuran, kita memastikan bahwa hanya ukuran valid yang dapat dilewatkan ke fungsi. Itu seperti memiliki menu dengan pilihan tetap - tidak ada kesalahan tentang apa ukuran yang tersedia!

Metode Enums

Berikut adalah tabel metode yang berguna untuk bekerja dengan Enums:

Metode	Deskripsi	Contoh
`Object.keys()`	Dapatkan semua kunci Enums	`Object.keys(Sizes)`
`Object.values()`	Dapatkan semua nilai Enums	`Object.values(Sizes)`
`Object.entries()`	Dapatkan pasangan kunci-nilai Enums	`Object.entries(Sizes)`
`Enum[key]`	Dapatkan nilai untuk kunci	`Sizes[Sizes.Small]`
`Enum[value]`	Dapatkan kunci untuk nilai (untuk Enums numerik)	`Sizes[0]`

Metode ini membantu Anda bekerja dengan Enums dalam cara yang berbeda, seperti mendapatkan semua ukuran yang tersedia atau menemukan nama ukuran dari nilaiannya.

Dan begitu saja! Anda telah mengambil langkah pertama ke dunia TypeScript Enums. Ingat, programming seperti belajar bahasa baru - itu memerlukan latihan, tapi segera Anda akan menjadi mahir dalam Enum-speak! Terus coding, tetap curiga, dan jangan lupa untuk bersenang-senang dalam perjalanan. Siapa tahu, mungkin Anda akan membuat Enums untuk rasa es krim kesukaan Anda berikutnya!

Credits: Image by storyset

Tutorial Sebelumnya:

TypeScript - Tupel

Tutorial Seterusnya:

TypeScript - Mana-mana