Pelindung Tipe TypeScript

Pelindung tipe merupakan fitur hebat dalam TypeScript yang memungkinkan pengembang untuk melakukan pemeriksaan saat dijalankan guna mempersempit tipe variabel. Hal ini memastikan informasi tipe yang lebih tepat, sehingga menghasilkan kode yang lebih aman dan lebih mudah diprediksi. Artikel ini membahas apa itu pelindung tipe dan cara menggunakannya secara efektif.

Apa itu Type Guard?

Pelindung tipe adalah ekspresi yang melakukan pemeriksaan saat dijalankan dan memungkinkan TypeScript untuk menyimpulkan tipe yang lebih spesifik untuk suatu variabel. Pelindung tipe membantu dalam membedakan antara tipe yang berbeda, terutama saat menangani tipe gabungan. Pelindung tipe dapat diimplementasikan menggunakan berbagai teknik, termasuk:

• Predikat tipe yang ditentukan pengguna
• Pernyataan tipe
• Pemeriksaan instans
• Menggunakan operator typeof
• Menggunakan operator in

Predikat Tipe yang Ditentukan Pengguna

Predikat tipe yang ditentukan pengguna adalah fungsi yang mengembalikan nilai boolean dan memiliki tipe pengembalian khusus yang menunjukkan tipe variabel yang sedang diperiksa. Berikut cara membuat dan menggunakannya:

function isString(value: any): value is string {
  return typeof value === 'string';
}

function printString(value: any) {
  if (isString(value)) {
    console.log(value.toUpperCase()); // TypeScript knows value is a string here
  } else {
    console.log('Not a string');
  }
}

Dalam contoh di atas, isString adalah predikat tipe yang ditentukan pengguna yang membantu TypeScript memahami bahwa value adalah string dalam blok if.

Penegasan Tipe

Pernyataan tipe memberi tahu TypeScript untuk memperlakukan variabel sebagai tipe tertentu. Metode ini tidak melakukan pemeriksaan saat runtime, tetapi memberi tahu kompiler TypeScript tentang tipe tersebut. Misalnya:

function printLength(value: any) {
  console.log((value as string).length); // Assert value is a string
}

Dalam contoh ini, value as string memberi tahu TypeScript untuk menganggap bahwa value adalah string tanpa melakukan pemeriksaan runtime.

Pemeriksaan Instansi

Pemeriksaan instans digunakan untuk menentukan apakah suatu objek merupakan instans dari kelas tertentu. Ini berguna untuk mempersempit tipe saat bekerja dengan kelas:

class Dog {
  bark() { console.log('Woof'); }
}

class Cat {
  meow() { console.log('Meow'); }
}

function speak(animal: Dog | Cat) {
  if (animal instanceof Dog) {
    animal.bark(); // TypeScript knows animal is a Dog here
  } else {
    animal.meow(); // TypeScript knows animal is a Cat here
  }
}

Dalam contoh ini, operator instanceof membantu TypeScript menyimpulkan tipe animal berdasarkan kelasnya.

Menggunakan Operator typeof

Operator typeof dapat digunakan untuk memeriksa tipe primitif seperti string, number, dan boolean:

function processValue(value: string | number) {
  if (typeof value === 'string') {
    console.log(value.toUpperCase()); // TypeScript knows value is a string here
  } else {
    console.log(value.toFixed(2)); // TypeScript knows value is a number here
  }
}

Di sini, typeof digunakan untuk memeriksa apakah value adalah string atau number dan mempersempit jenisnya sebagaimana mestinya.

Menggunakan Operator in

Operator in memeriksa keberadaan properti dalam suatu objek. Ini berguna untuk membedakan antara tipe yang memiliki properti umum:

interface Bird {
  fly: () => void;
}

interface Fish {
  swim: () => void;
}

function move(creature: Bird | Fish) {
  if ('fly' in creature) {
    creature.fly(); // TypeScript knows creature is a Bird here
  } else {
    creature.swim(); // TypeScript knows creature is a Fish here
  }
}

Dalam contoh ini, operator in membantu TypeScript menentukan apakah creature adalah Bird atau Fish berdasarkan keberadaan suatu metode.

Kesimpulan

Pelindung tipe TypeScript merupakan alat penting untuk bekerja dengan tipe secara fleksibel dan aman. Pelindung tipe memungkinkan pemeriksaan tipe yang lebih tepat dan dapat mencegah kesalahan runtime dengan memastikan bahwa tipe yang benar digunakan dalam berbagai skenario. Memahami dan menggunakan pelindung tipe secara efektif dapat menghasilkan kode TypeScript yang lebih tangguh dan mudah dipelihara.