Cara memasukkan properti objek sebagai string di TypeScript – Beragampengetahuan

Memperluas fungsionalitas yang ada dalam perangkat lunak dapat menjadi tantangan jika sistem tidak dirancang untuk beradaptasi secara efektif terhadap perubahan. ini Prinsip pembukaan dan penutupan (OCP)adalah konsep inti dari prinsip SOLID dalam pemrograman berorientasi objek, yang memberikan solusi dengan mengedepankan desain yang terbuka untuk perluasan tetapi tertutup untuk modifikasi. Hal ini memastikan perluasan yang mudah sambil mempertahankan fungsionalitas yang ada.

Dalam artikel ini, kita akan mengeksplorasi prinsip terbuka/tertutup, menyoroti pentingnya, dan mendemonstrasikan penerapannya menggunakan pola Strategi.

Memahami prinsip buka-tutup

Prinsip Terbuka-Tertutup yang dikemukakan oleh Bertrand Meyer menekankan:

1. Terbuka untuk ekspansi: Fungsi baru harus ditambahkan tanpa mengubah kode yang sudah ada.
2. Modifikasi dilarang: Tidak diperlukan perubahan pada kode yang ada saat memperluas perilaku.

Prinsip ini memastikan bahwa sistem tetap kuat dan dapat dipelihara bahkan ketika ada persyaratan baru yang muncul.

Contoh Masalah: Pelanggaran Prinsip Terbuka-Tertutup

Pertimbangkan fungsi kalkulator dasar yang melakukan operasi seperti penjumlahan dan pengurangan. menggunakan switch Pernyataan yang menangani operasi melanggar prinsip buka-tutup karena setiap operasi baru memerlukan perubahan fungsi yang sudah ada:

1 function calculate(operand1: number, operand2: number, operation: string): number {
2   switch (operation) {
3     case "add":
4       return operand1 + operand2;
5     case "subtract":
6       return operand1 - operand2;
7     default:
8       throw new Error("Unsupported operation");
9   }
10 }

Mengapa ada masalah:

Menambahkan operasi baru (seperti perkalian) memerlukan modifikasi fungsi perhitungan. Pendekatan ini mengikat logika secara erat, membuat kode lebih sulit untuk dipelihara atau diuji.

Pendekatan yang lebih baik: ikuti prinsip buka-tutup

menggunakan pola strategikita dapat mendesain kalkulator sedemikian rupa untuk mendukung operasi baru tanpa mengubah kode yang sudah ada.

melaksanakan

1. Tentukan antarmuka kebijakan

Buat antarmuka untuk menghitung strategi.

1 interface CalculationStrategy {
2   execute(operand1: number, operand2: number): number;
3 }

2. Strategi implementasi

Tentukan kelas untuk operasi tertentu seperti penjumlahan dan pengurangan.

1 class AddStrategy implements CalculationStrategy {
2   execute(operand1: number, operand2: number): number {
3     return operand1 + operand2;
4   }
5 }
6 
7 class SubtractStrategy implements CalculationStrategy {
8   execute(operand1: number, operand2: number): number {
9     return operand1 - operand2;
10   }
11 }

3. Buat kelas kalkulator

Menggunakan antarmuka strategi Calculator kelas untuk melakukan operasi.

1 class Calculator {
2   private strategy: CalculationStrategy;
3 
4   constructor(strategy: CalculationStrategy) {
5     this.strategy = strategy;
6   }
7 
8   setStrategy(strategy: CalculationStrategy) {
9     this.strategy = strategy;
10   }
11 
12   calculate(operand1: number, operand2: number): number {
13     return this.strategy.execute(operand1, operand2);
14   }
15 }

4. Tambahkan operasi baru

Ketika operasi baru diperlukan, cukup buat kelas strategi baru tanpa mengubah kode yang sudah ada. Misalnya:

1 class MultiplyStrategy implements CalculationStrategy {
2   execute(operand1: number, operand2: number): number {
3     return operand1 * operand2;
4   }
5 }

5. Contoh penggunaan

1 const calculator = new Calculator(new AddStrategy());
2 console.log(calculator.calculate(5, 3)); 
3 
4 calculator.setStrategy(new SubtractStrategy());
5 console.log(calculator.calculate(5, 3)); 
6 
7 calculator.setStrategy(new MultiplyStrategy());
8 console.log(calculator.calculate(5, 3)); 

Manfaat mengikuti prinsip buka-tutup

1. Skalabilitas: Fitur baru dapat ditambahkan dengan mudah.
2. pemeliharaan: Kode yang ada tetap tidak berubah, sehingga mengurangi risiko munculnya bug.
3. dapat digunakan kembali: Kelas strategi dapat digunakan kembali dalam proyek yang berbeda.

sebagai kesimpulan

ini Prinsip pembukaan dan penutupan Mempromosikan desain perangkat lunak yang kuat, terukur, dan dapat dipelihara. Dengan memanfaatkan pola seperti pola Strategi, Anda dapat merancang sistem yang mudah beradaptasi dengan kebutuhan baru tanpa mengubah fungsi yang sudah ada. Menerapkan prinsip ini akan membuktikan kode Anda di masa depan, mengurangi overhead pengembangan, dan meningkatkan keandalan.

Mulailah menerapkan prinsip terbuka/tertutup untuk membuat kode yang lebih bersih dan modular sekarang juga!