Prinsip sudut dan SOLID

SOLID adalah singkatan dari seperangkat prinsip yang membantu pengembang merancang aplikasi perangkat lunak yang lebih baik. Prinsip-prinsip ini adalah:

1. Prinsip Tanggung Jawab Tunggal (SRP)
   '' Sebuah kelas atau modul seharusnya hanya memiliki satu alasan untuk berubah.''
   Ini berarti bahwa sebuah kelas harus bertanggung jawab hanya untuk satu hal dan tidak boleh memiliki banyak tanggung jawab.
2. Prinsip Terbuka/Tertutup (OCP)
   '' Kelas harus terbuka untuk ekstensi tetapi ditutup untuk modifikasi.
   Ini berarti Anda harus dapat menambahkan fungsionalitas baru ke kelas tanpa mengubah kode yang sudah ada.
3. Prinsip Pergantian Liskov (LSP)
   '' Subtipe harus dapat diganti untuk tipe dasarnya.
   Ini berarti bahwa jika suatu kelas berasal dari kelas lain, kelas tersebut harus dapat menggantikan kelas induk tanpa menyebabkan perilaku yang tidak diharapkan.
4. Prinsip Segregasi Antarmuka (ISP)
   '' Klien tidak boleh dipaksa untuk bergantung pada antarmuka yang tidak mereka gunakan.
   Ini berarti bahwa suatu kelas tidak boleh dipaksa untuk mengimplementasikan antarmuka yang tidak diperlukan.
5. Dependency Inversion Principle (DIP)
   '' Modul tingkat tinggi tidak boleh bergantung pada modul tingkat rendah. Keduanya harus bergantung pada abstraksi. ''
   Ini berarti bahwa kelas harus bergantung pada abstraksi daripada implementasi konkret.

Di Angular, Anda bisa membuat layanan yang memiliki tanggung jawab tunggal, seperti mengambil data dari API atau menangani autentikasi pengguna. Berikut adalah contoh layanan yang mengambil data dari API:

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';

@Injectable()
export class DataService {
  constructor(private http: HttpClient) {}

  getData() {
    return this.http.get('https://jhonburbakollam.com/data');
  }
}

Prinsip Terbuka/Tertutup (OCP)

Di Angular, Anda dapat menggunakan pewarisan dan komposisi untuk membuat komponen yang dapat digunakan kembali yang dapat diperluas atau dimodifikasi tanpa mengubah kode aslinya. Berikut adalah contoh komponen yang menggunakan komposisi:

import { Component } from '@angular/core';

@Component({
  selector: 'app-button',
  template: '<button>Click me!</button>'
})
export class ButtonComponent {}

import { Component } from '@angular/core';
import { ButtonComponent } from './button.component';

@Component({
  selector: 'app-custom-button',
  template: '<button>Custom text</button>'
})
export class CustomButtonComponent extends ButtonComponent {}

Prinsip Pergantian Liskov (LSP)

Di Angular, Anda dapat menggunakan antarmuka untuk menentukan kontrak yang harus diikuti oleh kelas. Berikut adalah contoh antarmuka yang mendefinisikan kontrak:

export interface DataService {
  getData(): Observable<any>;
}

Jika Anda memiliki kelas yang mengimplementasikan antarmuka ini, Anda dapat menggantinya dengan kelas lain yang juga mengimplementasikan antarmuka tanpa menyebabkan perilaku yang tidak diharapkan.

Prinsip Segregasi Antarmuka (ISP)

Di Angular, Anda dapat menggunakan antarmuka untuk menentukan kontrak yang harus diikuti oleh kelas. Berikut adalah contoh antarmuka yang mengikuti ISP:

export interface Logger {
  log(message: string): void;
}

Dengan menggunakan antarmuka, Anda dapat memastikan bahwa kelas hanya bergantung pada antarmuka yang mereka butuhkan, daripada dipaksa untuk mengimplementasikan antarmuka yang tidak mereka gunakan.

Prinsip Inversi Ketergantungan (DIP)

Di Angular, Anda bisa menggunakan injeksi ketergantungan untuk menyediakan instance kelas ke kelas lain. Berikut adalah contoh layanan yang menggunakan injeksi ketergantungan:

import { Injectable } from '@angular/core';
import { DataService } from './data.service';

@Injectable()
export class LoggerService {
  constructor(private dataService: DataService) {}

  logData() {
    this.dataService.getData().subscribe((data) => {
      console.log(data);
    });
  }
}

Dengan menggunakan injeksi ketergantungan, Anda dapat memperoleh sambungan longgar antar kelas, yang memungkinkan Anda menukar implementasi tanpa mengubah kode kelas dependen.