Принципы Angular и SOLID

SOLID — это аббревиатура от набора принципов, помогающих разработчикам разрабатывать более качественные программные приложения. Эти принципы таковы:

1. Принцип единой ответственности (SRP)
   « У класса или модуля должна быть только одна причина для изменения».
   Это означает, что класс должен нести ответственность только за одну вещь и не должен иметь несколько обязанностей.
2. Принцип открытости/закрытости (OCP)
   « Класс должен быть открыт для расширения, но закрыт для модификации».
   Это означает, что вы должны иметь возможность добавлять новые функции в класс, не изменяя его существующий код.
3. Принцип замещения Лискова (LSP)
   « Подтипы должны быть взаимозаменяемыми для своих базовых типов».
   Это означает, что если класс является производным от другого класса, он должен иметь возможность заменить родительский класс, не вызывая непредвиденного поведения.
4. Принцип разделения интерфейсов (ISP)
   « Клиенты не должны зависеть от интерфейсов, которые они не используют».
   Это означает, что класс не следует заставлять реализовывать ненужные ему интерфейсы.
5. Принцип инверсии зависимостей (DIP)
   '' Модули высокого уровня не должны зависеть от модулей низкого уровня. Оба должны зависеть от абстракций. ''
   Это означает, что классы должны зависеть от абстракций, а не от конкретных реализаций.

В Angular вы можете создавать сервисы, которые несут единственную ответственность, например, получение данных из API или обработку аутентификации пользователя. Вот пример службы, которая извлекает данные из 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');
  }
}

Открытый/закрытый принцип (OCP)

В Angular вы можете использовать наследование и композицию для создания повторно используемых компонентов, которые можно расширять или модифицировать без изменения исходного кода. Вот пример компонента, использующего композицию:

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

Принцип замещения Лисков (LSP)

В Angular вы можете использовать интерфейсы для определения контрактов, которым должны следовать классы. Вот пример интерфейса, определяющего контракт:

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

Если у вас есть класс, реализующий этот интерфейс, вы можете заменить его другим классом, который также реализует этот интерфейс, не вызывая непредвиденного поведения.

Принцип разделения интерфейсов (ISP)

В Angular вы можете использовать интерфейсы для определения контрактов, которым должны следовать классы. Вот пример интерфейса, который следует за ISP:

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

Используя интерфейсы, вы можете гарантировать, что классы зависят только от тех интерфейсов, которые им нужны, а не вынуждены реализовывать интерфейсы, которые они не используют.

Принцип инверсии зависимостей (DIP)

В Angular вы можете использовать внедрение зависимостей для предоставления экземпляров классов другим классам. Вот пример службы, использующей внедрение зависимостей:

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

Используя внедрение зависимостей, вы можете добиться слабой связи между классами, что позволяет вам менять реализации без изменения кода зависимого класса.