TypeScript - Access Modifiers: Panduan Ramah untuk Privasi Kode

Hai teman, super bintang coding masa depan! ? Saya sangat senang menjadi panduannya Anda dalam perjalanan menarik ini melalui access modifiers TypeScript. Sebagai seseorang yang telah mengajarkan pemrograman selama tahun-tahun, saya bisa katakan kepada Anda bahwa memahami konsep ini adalah seperti belajar salam rahasia dunia pemrograman. Jadi, mari kita masuk dan buka misteri ini bersama!

Apa Itu Access Modifiers?

Sebelum kita masuk ke hal-hal spesifik, mari bicarakan apa itu access modifiers. Bayangkan Anda sedang membangun rumah pohon yang sangat keren (itu adalah kode kita!). Access modifiers seperti aturan yang Anda buat untuk siapa yang bisa mendaki, siapa yang bisa melihat ke dalam, dan siapa yang bisa menggunakan kompartemen rahasia. Mereka membantu kita mengendalikan bagaimana bagian-bagian kode kita dapat diakses dan digunakan.

Dalam TypeScript, kita memiliki tiga access modifiers utama:

Modifier	Deskripsi
public	Dapat diakses dari mana saja
private	Hanya dapat diakses dalam kelas yang sama
protected	Dapat diakses dalam kelas dan subclass-nya

Sekarang, mari kita jelajahi setiap modifikasi ini secara detail!

Public Access Modifier

Modifikasi public seperti membiarkan pintu rumah pohon Anda terbuka lebar. Siapa saja bisa masuk, menggunakan gantungan, atau meminjam buku komik Anda. Dalam istilah kode, ini berarti bagian mana saja dari program Anda dapat mengakses dan menggunakan elemen ini.

Ini adalah contoh yang menarik:

class Superhero {
public name: string;
public power: string;

constructor(name: string, power: string) {
this.name = name;
this.power = power;
}

public usePower() {
console.log(`${this.name} menggunakan ${this.power}!`);
}
}

const spiderman = new Superhero("Spider-Man", "web-slinging");
console.log(spiderman.name); // Output: Spider-Man
spiderman.usePower(); // Output: Spider-Man menggunakan web-slinging!

Dalam contoh ini, name, power, dan usePower() semua publik. Kita dapat mengakses dan menggunakannya dari mana saja di kode kita. Itu seperti Spider-Man yang bebas melintasi kota!

Private Access Modifiers

Sekarang, mari bicarakan private. Ini seperti memiliki buku harian rahasia di rumah pohon Anda yang hanya Anda yang bisa membacanya. Dalam TypeScript, anggota private hanya dapat diakses dalam kelas yang sama.

mari perbarui kelas Superhero:

class Superhero {
public name: string;
private secretIdentity: string;

constructor(name: string, secretIdentity: string) {
this.name = name;
this.secretIdentity = secretIdentity;
}

private changeClothes() {
console.log("Perubahan cepat di dalam kios telepon!");
}

public goOnMission() {
this.changeClothes();
console.log(`${this.name} siap untuk aksi!`);
}
}

const superman = new Superhero("Superman", "Clark Kent");
console.log(superman.name); // Output: Superman
// console.log(superman.secretIdentity); // Kesalahan! secretIdentity adalah private
// superman.changeClothes(); // Kesalahan! changeClothes() adalah private
superman.goOnMission(); // Ini berfungsi! Output: Perubahan cepat di dalam kios telepon! Superman siap untuk aksi!

Lihat bagaimana kita tidak bisa mengakses secretIdentity atau memanggil changeClothes() secara langsung? Itu kekuatan private! Itu menjaga rahasia Superman aman.

Protected Access Modifiers

Terakhir tetapi bukan yang paling kurang, kita memiliki protected. Bayangkan ini seperti aturan khusus rumah pohon yang berlaku untuk Anda dan saudara Anda, tapi tidak untuk anak-anak lingkungan. Dalam TypeScript, anggota protected dapat diakses dalam kelas dan subclass-nya.

mari buat keluarga Superhero:

class Superhero {
public name: string;
protected superpower: string;

constructor(name: string, superpower: string) {
this.name = name;
this.superpower = superpower;
}

protected useSuperpowerInternal() {
console.log(`Menggunakan ${this.superpower} secara internal`);
}
}

class Sidekick extends Superhero {
public useSuperheroPower() {
console.log(`${this.name} meminjam kekuatan: ${this.superpower}`);
this.useSuperpowerInternal();
}
}

const batman = new Superhero("Batman", "gadget");
const robin = new Sidekick("Robin", "akrobatik");

// console.log(batman.superpower); // Kesalahan! superpower adalah protected
// batman.useSuperpowerInternal(); // Kesalahan! useSuperpowerInternal() adalah protected

robin.useSuperheroPower(); // Ini berfungsi! Output: Robin meminjam kekuatan: akrobatik Menggunakan akrobatik secara internal

Di sini, Sidekick dapat mengakses anggota protected kelas Superhero, tapi kita tidak bisa mengaksesnya secara langsung dari luar kelas.

Penutup

Dan begitulah, para murid pemrograman saya! Kita telah mengeksplorasi dunia rahasia access modifiers TypeScript. Ingat:

1. public adalah untuk semua orang (seperti taman umum)
2. private adalah hanya untuk kelas itu sendiri (seperti buku harian pribadi Anda)
3. protected adalah untuk kelas dan anak kelas-nya (seperti rahasia keluarga)

Menggunakan modifier ini secara bijaksana akan membantu Anda menciptakan kode yang lebih aman, terorganisir, dan mudah dipelihara. Itu seperti menjadi superhero dunia pemrograman - Anda tahu kapan untuk membagikan kekuatan Anda dan kapan untuk menyembunyikannya!

Sementara Anda berlatih dengan konsep ini, bayangkan Anda sedang mendesain tim superhero Anda sendiri. Siapa yang bisa mengetahui apa? Bagaimana Anda menjaga keseimbangan antara kerjasama dan identitas rahasia? Itu adalah kesenangan pemrograman - Anda yang memutuskan keputusan menarik ini!

Terus coding, terus belajar, dan ingat: dengan kekuatan yang besar datang tanggung jawab yang besar... dan kelas TypeScript yang sangat menarik! ??‍♂️?‍♀️

Credits: Image by storyset