Refatorar significa reescrever o código

Refatorar significa reescrever o código?

Refatorar um código não é exatamente o mesmo que reescrevê-lo. Embora ambos os processos envolvam a alteração do código-fonte de um programa, eles têm objetivos e abordagens diferentes.

Refatorar um código significa fazer melhorias específicas no código existente, tornando-o mais legível, mais eficiente e mais fácil de manter, sem alterar sua funcionalidade. O objetivo da refatoração é melhorar a estrutura do código, eliminar duplicações, simplificar o código e torná-lo mais robusto. A refatoração é uma prática importante na engenharia de software, pois ajuda a manter a qualidade do código ao longo do tempo.

Na prática

Imagine que você tenha um código que lida com operações de um aplicativo bancário, incluindo o cálculo de juros e a exibição de informações da conta. Aqui está um código inicial que mistura essas responsabilidades:

    class ContaBancaria {
      constructor(private saldo: number, private taxaJuros: number) {}

      calcularJuros(meses: number): number {
        return this.saldo * this.taxaJuros * meses;
      }

      exibirInformacoes() {
        console.log(`Saldo: R$${this.saldo.toFixed(2)}`);
        console.log(`Taxa de Juros: ${this.taxaJuros * 100}%`);
      }
    }

    const conta = new ContaBancaria(1000, 0.05);
    conta.exibirInformacoes();
    console.log(`Juros para 3 meses: R$${conta.calcularJuros(3).toFixed(2)}`);

Neste código, a classe ContaBancaria está encarregada tanto de calcular juros quanto de exibir informações da conta, o que não segue o princípio da divisão de responsabilidades. Vamos refatorar o código para separar essas responsabilidades:

    class ContaBancaria {
      constructor(private saldo: number, private taxaJuros: number) {}

      calcularJuros(meses: number): number {
        return this.saldo * this.taxaJuros * meses;
      }

      exibirInformacoes() {
        console.log(`Saldo: R$${this.saldo.toFixed(2)}`);
        console.log(`Taxa de Juros: ${this.taxaJuros * 100}%`);
      }
    }

    class AplicacaoFinanceira {
      constructor(private conta: ContaBancaria) {}

      exibirInformacoes() {
        this.conta.exibirInformacoes();
      }

      calcularJuros(meses: number): number {
        return this.conta.calcularJuros(meses);
      }
    }

    const conta = new ContaBancaria(1000, 0.05);
    const aplicacao = new AplicacaoFinanceira(conta);

    aplicacao.exibirInformacoes();
    console.log(`Juros para 3 meses: R$${aplicacao.calcularJuros(3).toFixed(2)}`);

Agora, o código está organizado de forma mais limpa, com a classe ContaBancaria responsável apenas pelas operações relacionadas à conta e a classe AplicacaoFinanceira encarregada de coordenar essas operações e exibir informações. Isso torna o código mais claro, mais fácil de manter e segue o princípio do "Clean Code" de divisão de responsabilidades. Essa refatoração foi feita sem a necessidade de reescrever o código.

E quando reescrever?

Por outro lado, reescrever um código implica criar uma nova implementação do mesmo software a partir do zero. Isso pode ser necessário quando o código existente está tão desorganizado, obsoleto ou com problemas fundamentais que é mais eficiente e eficaz começar do zero. A reescrita envolve a criação de um novo código-fonte com base nos requisitos e funcionalidades existentes, mas não é uma simples modificação do código existente.

A escolha entre refatorar ou reescrever um código depende da situação. A refatoração é preferível quando o código ainda é válido, mas precisa de melhorias. Ela é mais rápida e menos arriscada do que uma reescrita completa. Por outro lado, a reescrita é apropriada quando o código atual é tão problemático que a correção de seus problemas seria mais difícil e demorada do que começar do zero.

Ambos os processos são ferramentas valiosas no kit de um desenvolvedor, e a decisão de refatorar ou reescrever deve ser baseada na avaliação das necessidades específicas de um projeto, levando em consideração os custos, benefícios e riscos envolvidos. O objetivo final é sempre melhorar a qualidade e a manutenibilidade do código, garantindo que ele atenda às necessidades dos usuários e do negócio.