Boas Práticas - DRY, KISS, YAGNI
Tags: designpatterns, javascript, development, node
Published: 2023-06-30 00:15:22

As boas práticas de desenvolvimento DRY, KISS e YAGNI são princípios fundamentais que podem ajudar os desenvolvedores a escrever código mais limpo, eficiente e fácil de manter. Aqui está uma breve explicação de cada um deles:

**DRY** (Don't Repeat Yourself - Não se repita): DRY é um princípio que incentiva os desenvolvedores a evitar a duplicação de código. Em vez de ter o mesmo trecho de código repetido em vários lugares, é preferível abstrair esse código em uma função, classe ou componente reutilizável. Dessa forma, se houver a necessidade de fazer alterações, elas só precisam ser feitas em um único lugar, o que reduz a possibilidade de erros e facilita a manutenção do código.

Exemplo: Função para calcular a média de uma lista de números.

```
// Versão não-DRY
function calcularMedia(lista) {
  let soma = 0;
  for (let i = 0; i < lista.length; i++) {
      soma += lista[i];
  }
    return soma / lista.length;
}
		
// Versão DRY
function calcularMedia(lista) {
  const soma = lista.reduce((acc, num) => acc + num, 0);
	return soma / lista.length;
}
```
Na versão não-DRY, o cálculo da soma é repetido em um loop. Já na versão DRY, a função `reduce` é usada para calcular a soma sem repetir o código.

**KISS** (Keep It Simple, Stupid - Mantenha Simples, Estúpido): O princípio KISS sugere que o código deve ser simples e direto. Em vez de criar soluções complexas e sofisticadas, os desenvolvedores devem buscar a simplicidade, tornando o código mais fácil de entender, depurar e manter. Isso envolve evitar a complexidade desnecessária, utilizar nomes claros para variáveis, funções e classes, e evitar soluções complicadas quando há alternativas mais simples e eficientes

Exemplo: Verificar se um número é par.

```
// Versão não-KISS
function isPar(numero) {
  if (numero % 2 === 0) {
	return true;
  } else {
	return false;
  }
}
		
// Versão KISS
function isPar(numero) {
  return numero % 2 === 0;
}
```
Na versão **não-KISS**, o resultado da expressão 
`numero % 2 === 0` já é um valor booleano, então não é necessário o uso do bloco `if` para retornar `true` ou `false`. A versão **KISS** simplifica a função, retornando diretamente o resultado da expressão.

**YAGNI** (You Ain't Gonna Need It - Você não vai precisar disso): YAGNI é um princípio que adverte contra a inclusão de funcionalidades ou código que ainda não são necessários. Os desenvolvedores devem se concentrar em implementar apenas o que é necessário no momento, evitando adicionar recursos ou funcionalidades especulativas que possam nunca ser utilizados. Isso evita a criação de código desnecessário, reduz a complexidade do sistema e facilita a manutenção futura.

Exemplo: Classe de um carro com atributo "cor".

```
// Versão não-YAGNI
class Carro {
   constructor(cor, marca) {
        this.cor = cor;
        this.marca = marca;
        this.ano = 2023;
	this.combustivel = 'gasolina';
   }
		
     // ...outros métodos
}
		
// Versão YAGNI
class Carro {
   constructor(cor, marca) {
	this.cor = cor;
	this.marca = marca;
   }
		
	 // ...outros métodos
}
```

Na versão não-YAGNI, foram adicionados atributos como "ano" e "combustível" ao construtor da classe, mesmo que eles não sejam necessários para o exemplo. Na versão YAGNI, esses atributos foram removidos para manter a classe simples e incluir apenas o necessário.

Essas três boas práticas são complementares e podem ser aplicadas em conjunto para promover um código mais limpo, eficiente e fácil de manter. Elas ajudam a evitar a duplicação de código, simplificar soluções e evitar o excesso de complexidade, resultando em um software mais robusto e de qualidade.

https://github.com/ryanmcdermott/clean-code-javascript