Tag / solid

by evelyn

Como aplicar SOLID em uma aplicação Angular 18+

Aplicando SOLID no Angular

✅ SRP (Responsabilidade Única) → Separe lógica de negócio em services e mantenha componentes focados apenas na UI.

✅ OCP (Aberto/Fechado) → Use herança ou injeção de dependência para estender funcionalidades sem modificar código existente.

✅ LSP (Substituição de Liskov) → Subclasses devem poder substituir superclasses sem alterar o comportamento esperado. Use interfaces para garantir compatibilidade.

✅ ISP (Segregação de Interfaces) → Prefira múltiplas interfaces menores ao invés de forçar classes a implementar métodos desnecessários.

✅ DIP (Inversão de Dependência) → Dependa de abstrações (interfaces ou classes abstratas) e use injeção de dependência para reduzir o acoplamento.

A versão 18+ do Angular trouxe uma série de melhorias significativas, como a introdução do modo standalone e um suporte aprimorado à injeção de dependência, facilitando a aplicação dos princípios SOLID de forma mais eficiente e intuitiva.

Para ajudar você a colocar esses conceitos em prática, aqui está um guia com exemplos práticos, mostrando tanto as abordagens incorretas quanto as corretas para cada um dos princípios do SOLID.

1. SRP – Princípio da Responsabilidade Única

“Uma classe deve ter apenas uma razão para mudar e focar exclusivamente em uma única responsabilidade.”
Em outras palavras, cada componente ou classe deve resolver um único problema, evitando a mistura de tarefas não relacionadas. Isso garante código mais coeso, fácil de manter e menos propenso a bugs. Por exemplo, não deve misturar lógica de negócios com chamadas HTTP ou outras tarefas que não sejam diretamente relacionadas à sua função principal.

Exemplo Errado: Componente fazendo tudo

import { Component, inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';

@Component({
  selector: 'app-user-profile',
  standalone: true,
  template: `
    <div *ngIf="user">
      <h1>{{ user.name }}</h1>
      <p>Email: {{ user.email }}</p>
    </div>
  `,
})
export class UserProfileComponent {
  user: any;
  private http = inject(HttpClient);

  constructor() {
    this.loadUser();
  }

  loadUser() {
    this.http.get('/api/user').subscribe((data) => (this.user = data));
  }
}
Continue reading →
by evelyn

Um pouco sobre SOLID.

SOLID:

1. S (SRP): Uma classe deve ter uma única responsabilidade.
2. O (OCP): Código deve ser aberto para extensão, mas fechado para modificação.
3. L (LSP): Subclasses devem poder substituir suas classes base sem causar erros.
4. I (ISP): Interfaces devem ser específicas para evitar métodos desnecessários.
5. D (DIP): Dependa de abstrações, não de implementações concretas.

O SOLID é um conjunto de cinco princípios de design de software que visam melhorar a qualidade, a manutenibilidade e a escalabilidade do código. Vamos começar pela letra S, que representa o Princípio da Responsabilidade Única (Single Responsibility Principle – SRP).

S – Princípio da Responsabilidade Única (SRP)

Definição: Uma classe deve ter apenas uma razão para mudar, ou seja, deve ter apenas uma responsabilidade.

Explicação: Esse princípio sugere que uma classe deve ser focada em fazer apenas uma coisa. Se uma classe tem múltiplas responsabilidades, ela se torna mais complexa e difícil de manter. Quando uma classe tem uma única responsabilidade, fica mais fácil de entender, testar e modificar.

Exemplo Prático:

Suponha que você tenha uma classe Pedido que é responsável por gerenciar os detalhes de um pedido e também por salvar o pedido no banco de dados.

class Pedido:
    def __init__(self, id, cliente, itens):
        self.id = id
        self.cliente = cliente
        self.itens = itens

    def calcular_total(self):
        return sum(item['preco'] * item['quantidade'] for item in self.itens)

    def salvar_pedido(self):
        # Lógica para salvar o pedido no banco de dados
        pass
Continue reading →