TypeScript - Access Modifiers: Panduan Kebaikan untuk Kerahasiaan Kod

Hai sana, bakat coding masa depan! ? Saya begitu gembira untuk menjadi pandu Anda dalam perjalanan menarik ini melalui modifier akses TypeScript. Sebagai seseorang yang telah mengajar pemrograman selama tahun tahun, saya dapat katakan kepada Anda bahwa memahami konsep ini seperti belajar salam rahasia dunia coding. Jadi, mari kita masuk dan buka misteri ini bersama!

Apa Itu Modifier Akses?

Sebelum kita melompat ke hal-hal khusus, mari kita bicarakan apa itu modifier akses. Bayangkan Anda sedang membangun treehouse yang sangat keren (itu adalah kod kita!). Modifier akses adalah seperti aturan yang Anda tetapkan untuk siapa yang boleh mendaki, siapa yang boleh melihat di dalam, dan siapa yang boleh menggunakan kompartemen rahasia. Mereka membantu kita mengawal bagaimana bagian-bagian kod kita dapat diakses dan digunakan.

Dalam TypeScript, kita memiliki tiga modifier akses utama:

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

Sekarang, mari kita jelajahi setiap satu dari ini secara detil!

Modifier Akses Public

Modifier public adalah seperti meninggalkan pintu treehouse Anda terbuka lebar. Siapa saja dapat masuk, menggunakan gantungan, atau meminjam buku komik Anda. Dalam istilah kod, ini berarti bagian mana pun 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", "tembakan jaring");
console.log(spiderman.name); // Output: Spider-Man
spiderman.usePower(); // Output: Spider-Man menggunakan tembakan jaring!

Dalam contoh ini, name, power, dan usePower() semua adalah public. Kita dapat mengakses dan menggunakan mereka dari mana saja dalam kod kita. Itu seperti Spider-Man melompat bebas di kota!

Modifier Akses Private

Sekarang, mari bicarakan private. Ini seperti memiliki buku harian rahasia di treehouse Anda yang hanya Anda sendiri yang dapat 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 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); // Error! secretIdentity adalah private
// superman.changeClothes(); // Error! changeClothes() adalah private
superman.goOnMission(); // Ini berfungsi! Output: Perubahan cepat di kios telepon! Superman siap untuk aksi!

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

Modifier Akses Protected

Terakhir tetapi bukan kurang penting, kita memiliki protected. Bayangkan ini sebagai aturan khusus treehouse yang berlaku untuk Anda dan saudara Anda, tetapi bukan untuk anak-anak lingkungan. Dalam TypeScript, anggota protected dapat diakses dalam kelas dan subclassnya.

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 kuasa: ${this.superpower}`);
this.useSuperpowerInternal();
}
}

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

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

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

Di sini, Sidekick dapat mengakses anggota protected kelas Superhero, tetapi kita tidak dapat mengakses mereka secara langsung dari luar kelas.

Penutup

Dan begitulah, murid coding saya! Kita telah menjelajahi dunia rahasia modifier akses TypeScript. Ingat:

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

Menggunakan modifier ini secara bijak akan membantu Anda menciptakan kod yang lebih aman, terorganisir, dan mudah dipelihara. Itu seperti menjadi superhero dunia pemrograman - Anda tahu kapan untuk berbagi kuasa Anda dan kapan untuk menjaga mereka dalam rahasia!

Sementara Anda berlatih dengan konsep ini, bayangkan Anda merancang tim superhero sendiri. Siapa yang akan mengetahui apa? Bagaimana Anda menjaga keseimbangan antara kerjasama dan rahasia? Itu adalah kesenangan pemrograman - Anda mendapatkan membuat keputusan menarik ini!

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

Credits: Image by storyset