Função Pura: O Que É e Por Que Você Deve Usar?

Se você já programou por um tempo, provavelmente ouviu falar de funções puras. Mas o que exatamente isso significa e por que elas são tão valorizadas?

Elas fazem parte do paradigma da programação funcional, mas não se limitam a ele. Mesmo em código orientado a objetos ou misto, entender e aplicar funções puras pode deixar seu código mais previsível, organizado e fácil de testar.

Vamos tentar entender como elas funcionam?

O Que É uma Função Pura?

Uma função pura segue duas regras simples:

1. Sempre retorna o mesmo resultado para a mesma entrada

Se você passar os mesmos valores como argumento, ela sempre devolverá o mesmo resultado.

2. Não causa efeitos colaterais

Continue reading →

Ordenando Objetos em JavaScript com QuickSort e pesquisando com Binary Search

Se você já precisou ordenar um array de objetos em JavaScript, provavelmente usou o método .sort(). No entanto, entender e implementar algoritmos clássicos de ordenação, como o QuickSort, pode ser muito útil para aprendizado e otimização.

Neste post, vamos criar uma função QuickSort capaz de ordenar um array de objetos de forma dinâmica, depois, usaremos o Binary Search para buscar elementos de forma eficiente.

O que é QuickSort?

QuickSort é um algoritmo eficiente de ordenação que segue o paradigma Dividir para Conquistar. Ele funciona assim:

1. Escolhe um elemento como pivô.

Continue reading →

Code Review Eficaz

Fazer um code review eficaz envolve uma combinação de análise técnica, atenção a boas práticas e comunicação construtiva. Abaixo estão os principais pontos a considerar, incluindo a relevância de conceitos como SOLID, OOP e complexidade de código:

1. O que Verificar no Code Review?

Funcionalidade e Requisitos

  • Alinhamento com os requisitos: O código resolve o problema proposto?
  • Tratamento de casos extremos (edge cases): Ex.: divisão por zero, entradas inválidas, falhas de rede.
  • Impacto em outras partes do sistema: O código quebra funcionalidades existentes?

Qualidade do Código

  • Princípios SOLID (extremamente relevantes):
    • Single Responsibility: Uma classe/função faz apenas uma coisa?
    • Open/Closed: O código está aberto para extensão, mas fechado para modificação?
    • Liskov Substitution: As subclasses podem substituir suas classes base sem quebrar o sistema?
    • Interface Segregation: Interfaces são específicas para o cliente que as usa?
    • Dependency Inversion: Módulos dependem de abstrações, não de implementações?
  • Orientação a Objetos (OOP):
    • Encapsulamento: Dados e comportamentos estão protegidos?
    • Herança vs. Composição: A hierarquia de classes é justificada ou há complexidade desnecessária?
    • Polimorfismo: Há uso adequado de interfaces ou classes abstratas?
  • Programação Funcional (FP)
    • Imutabilidade: O código evita mutações desnecessárias de estado?
    • Funções puras: Funções sempre retornam o mesmo resultado para a mesma entrada?
    • Composição de funções: O código utiliza composição ao invés de sequências complexas de instruções?
    • Evita efeitos colaterais: Há dependências globais ou mutações inesperadas?
    • Uso adequado de Higher-Order Functions: O código se beneficia de funções como mapreduce e filter para evitar loops imperativos?
  • Complexidade:
    • Complexidade Ciclomática: Funções/métodos têm muitas ramificações (if/else, loops)? Valores altos indicam código difícil de testar e manter.
    • Código duplicado: Há violação do DRY (Don’t Repeat Yourself)?
    • Legibilidade: O código é fácil de entender? Nomes de variáveis/métodos são claros?
Continue reading →

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

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 →