Principios Angular y SÓLIDO

SOLID es un acrónimo de un conjunto de principios que ayudan a los desarrolladores a diseñar mejores aplicaciones de software. Estos principios son:

1. Principio de responsabilidad única (SRP)
   '' Una clase o módulo debe tener una sola razón para cambiar. ''
   Esto significa que una clase debe ser responsable de una sola cosa y no debe tener múltiples responsabilidades.
2. Principio Abierto/Cerrado (OCP)
   '' Una clase debe estar abierta para extensión pero cerrada para modificación.”
   Esto significa que debería poder agregar nuevas funciones a una clase sin cambiar su código existente.
3. Principio de sustitución de Liskov (LSP)
   " Los subtipos deben ser sustituibles por sus tipos base".
   Esto significa que si una clase se deriva de otra clase, debería poder reemplazar la clase principal sin causar ningún comportamiento inesperado.
4. Principio de segregación de interfaces (ISP)
   " No se debe obligar a los clientes a depender de interfaces que no utilizan".
   Esto significa que no se debe forzar a una clase a implementar interfaces que no necesita.
5. Principio de inversión de dependencia (DIP)
   '' Los módulos de alto nivel no deben depender de los módulos de bajo nivel. Ambos deberían depender de abstracciones. Esto
   significa que las clases deberían depender de abstracciones en lugar de implementaciones concretas.

En Angular, puede crear servicios que tengan una sola responsabilidad, como obtener datos de una API o manejar la autenticación de usuarios. Este es un ejemplo de un servicio que obtiene datos de una 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');
  }
}

Principio abierto/cerrado (OCP)

En Angular, puede usar la herencia y la composición para crear componentes reutilizables que se pueden ampliar o modificar sin cambiar su código original. Aquí hay un ejemplo de un componente que usa composición:

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 {}

Principio de sustitución de Liskov (LSP)

En Angular, puede usar interfaces para definir contratos que deben seguir las clases. Aquí hay un ejemplo de una interfaz que define un contrato:

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

Si tiene una clase que implementa esta interfaz, puede sustituirla por otra clase que también implemente la interfaz sin causar ningún comportamiento inesperado.

Principio de segregación de interfaz (ISP)

En Angular, puede usar interfaces para definir contratos que deben seguir las clases. Aquí hay un ejemplo de una interfaz que sigue a ISP:

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

Mediante el uso de interfaces, puede asegurarse de que las clases solo dependan de las interfaces que necesitan, en lugar de verse obligadas a implementar interfaces que no usan.

Principio de inversión de dependencia (DIP)

En Angular, puede usar la inyección de dependencia para proporcionar instancias de clases a otras clases. Aquí hay un ejemplo de un servicio que usa inyección de dependencia:

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);
    });
  }
}

Al usar la inyección de dependencia, puede lograr un acoplamiento flexible entre clases, lo que le permite intercambiar implementaciones sin cambiar el código de la clase dependiente.