JavaScript - Enkapsulasi

Halo teman-teman pemrograman yang sedang berkembang! Hari ini, kita akan memulai perjalanan yang menarik ke dunia enkapsulasi JavaScript. Jangan khawatir jika Anda baru dalam pemrograman – saya akan menjadi panduan ramah Anda, dan kita akan mengembangkan konsep ini bersama-sama, langkah demi langkah. Jadi, siapkan tas virtual Anda, dan mari kita mulai!

Apa Itu Enkapsulasi?

Bayangkan Anda memiliki sebuah peti harta. Anda tentu tidak mau siapa saja membukanya dan mengambil permata yang berharga Anda, kan? Itu sebenarnya apa yang enkapsulasi lakukan dalam pemrograman. Itu seperti memasukkan kode Anda ke dalam gelembung perlindungan, memungkinkan hanya bagian tertentu saja yang dapat diakses dari luar.

Dalam kata yang sederhana, enkapsulasi adalah pengemasan data dan metode yang bekerja pada data tersebut dalam satu unit atau objek. Itu adalah cara untuk menyembunyikan detail internal bagaimana objek bekerja dan hanya mengungkapkan apa yang diperlukan.

Mengapa Kita Butuh Enkapsulasi?

Anda mungkin bertanya-tanya, " Mengapa kita butuh hal menarik ini, enkapsulasi?" Well, mari saya ceritakan sedikit cerita.

Pada zaman lalu, di negeri kode spaghetti, tinggal seorang pemrogram bernama Bob. Kode Bob terbuka untuk siapa saja yang mau mengubahnya, dan segera, pemrogram lain mulai merusaknya. Kekacauan terjadi! Tidak ada yang tahu bagian mana dari kode melakukan apa, dan bug berlipat ganda seperti kelinci.

Ini adalah tempat enkapsulasi datang untuk menyelamatkan. Itu membantu kita:

1. Perlindungan data dari modifikasi yang tidak disengaja
2. Menyembunyikan detail implementasi yang kompleks
3. Menyusun kode kita menjadi lebih terorganisir dan mudah dipelihara
4. Mengurangi dependensi antara bagian lain dari kode kita

Cara-Cara Berbeda untuk Mencapai Enkapsulasi di JavaScript

Dalam JavaScript, kita memiliki beberapa trik di saku kita untuk mencapai enkapsulasi. Mari kita jelajahi satu per satu:

Mencapai Enkapsulasi Menggunakan Penutupan Fungsi

Penutupan adalah seperti gelembung magis di JavaScript yang mengingat lingkungan tempat mereka diciptakan. Kita dapat menggunakan mereka untuk membuat variabel dan metode pribadi. Mari kita lihat contoh:

function createBankAccount(initialBalance) {
let balance = initialBalance;

return {
deposit: function(amount) {
balance += amount;
console.log(`Setoran ${amount}. Saldo baru adalah ${balance}`);
},
withdraw: function(amount) {
if (amount <= balance) {
balance -= amount;
console.log(`Penarikan ${amount}. Saldo baru adalah ${balance}`);
} else {
console.log("Dana tidak cukup!");
}
},
getBalance: function() {
return balance;
}
};
}

const myAccount = createBankAccount(1000);
myAccount.deposit(500);  // Setoran 500. Saldo baru adalah 1500
myAccount.withdraw(200); // Penarikan 200. Saldo baru adalah 1300
console.log(myAccount.getBalance()); // 1300
console.log(myAccount.balance); // undefined

Dalam contoh ini, balance adalah variabel pribadi kita. Itu tidak dapat diakses secara langsung dari luar fungsi createBankAccount. Kita hanya dapat berinteraksi dengannya melalui metode yang kita perlihatkan: deposit, withdraw, dan getBalance. Ini adalah enkapsulasi dalam aksi!

Mencapai Enkapsulasi Menggunakan Kelas ES6 dan Variabel Pribadi

Dengan pengenalan kelas ES6, kita mendapatkan cara yang lebih familiar untuk membuat objek dan mencapai enkapsulasi. Ini adalah cara kita dapat melakukannya:

class BankAccount {
#balance;  // Field pribadi

constructor(initialBalance) {
this.#balance = initialBalance;
}

deposit(amount) {
this.#balance += amount;
console.log(`Setoran ${amount}. Saldo baru adalah ${this.#balance}`);
}

withdraw(amount) {
if (amount <= this.#balance) {
this.#balance -= amount;
console.log(`Penarikan ${amount}. Saldo baru adalah ${this.#balance}`);
} else {
console.log("Dana tidak cukup!");
}
}

getBalance() {
return this.#balance;
}
}

const myAccount = new BankAccount(1000);
myAccount.deposit(500);  // Setoran 500. Saldo baru adalah 1500
myAccount.withdraw(200); // Penarikan 200. Saldo baru adalah 1300
console.log(myAccount.getBalance()); // 1300
console.log(myAccount.#balance); // SyntaxError: Field '#balance' harus dideklarasikan dalam kelas yang menyelubungi

Dalam contoh ini, kita menggunakan simbol # untuk mendeklarasikan balance sebagai field pribadi. Ini berarti itu hanya dapat diakses dalam kelas BankAccount, tidak dari luar.

Mencapai Enkapsulasi Menggunakan Getter dan Setter

Getter dan setter adalah metode khusus yang memungkinkan kita mendefinisikan bagaimana properti diakses atau dimodifikasi. Mereka seperti penjaga keamanan untuk properti objek kita. Mari kita lihat mereka dalam aksi:

class Circle {
constructor(radius) {
this._radius = radius;
}

get radius() {
return this._radius;
}

set radius(value) {
if (value <= 0) {
throw new Error("Radius harus positif");
}
this._radius = value;
}

get area() {
return Math.PI * this._radius ** 2;
}
}

const myCircle = new Circle(5);
console.log(myCircle.radius); // 5
console.log(myCircle.area);   // 78.53981633974483

myCircle.radius = 10;
console.log(myCircle.radius); // 10

myCircle.radius = -1; // Error: Radius harus positif

Dalam contoh ini, kita menggunakan getter untuk membaca radius dan setter untuk memodifikasinya. Setter termasuk pemeriksaan untuk memastikan radius selalu positif. Kita juga memiliki getter untuk area yang menghitung luas secara langsung.

Manfaat Enkapsulasi di JavaScript

Sekarang kita telah melihat bagaimana mencapai enkapsulasi, mari kita ringkasan manfaatnya:

1. Perlindungan Data: Itu menghindari akses yang tidak resmi ke internal objek kita.
2. Flexibilitas: Kita dapat mengubah implementasi internal tanpa mengganggu kode eksternal yang menggunakan objek kita.
3. Modularitas: Itu membantu dalam membuat unit kode self-contained, membuat kode kita lebih modular dan mudah dikelola.
4. Debugging: Dengan membatasi di mana data dapat dimodifikasi, itu mudah untuk melacak bug.
5. Abstraksi: Itu memungkinkan kita menyembunyikan detail implementasi yang kompleks dan menyediakan antar muka sederhana untuk menggunakan objek kita.

Tabel Metode

Berikut adalah tabel praktis yang menggabungkan metode yang kita diskusikan untuk mencapai enkapsulasi:

Metode	Deskripsi	Contoh
Penutupan Fungsi	Menggunakan penutupan untuk membuat variabel pribadi	function createObject() { let privateVar = 0; return { getVar: () => privateVar }; }
Kelas ES6 dengan Field Pribadi	Menggunakan # untuk mendeklarasikan field pribadi dalam kelas	class MyClass { #privateField; constructor() { this.#privateField = 0; } }
Getter dan Setter	Menggunakan metode khusus untuk mengontrol akses ke properti	class MyClass { get prop() { return this._prop; } set prop(value) { this._prop = value; } }

Danitu, teman-teman! Kita telah melintasi negeri enkapsulasi, dari konsep dasarnya ke berbagai cara implementasinya di JavaScript. Ingat, enkapsulasi adalah seperti seorang penjaga rahasia yang baik – itu tahu apa yang harus dibagikan dan apa yang harus disembunyikan. Dalam perjalanan pemrograman Anda, Anda akan menemukan enkapsulasi menjadi teman yang dapat dipercaya dalam menciptakan kode yang kuat dan mudah dipelihara.

Teruslatih, tetap kurang, dan selamat coding!

Credits: Image by storyset