UI2Code

Princípios KISS, YAGNI e DRY

Imagem para Princípios KISS, YAGNI e DRY

It managementPostado em  5 min de leitura

Hi, Cyaanns !!!

Os princípios KISS, YAGNI e DRY são princípios de programação que ajudam os desenvolvedores a criar código limpo, eficiente e fácil de manter.

O princípio KISS sugere que a solução mais simples é frequentemente a melhor, e os desenvolvedores devem sempre buscar manter as coisas simples e diretas, evitando a complexidade desnecessária sempre que possível.

O princípio YAGNI diz que devemos focar em criar apenas as funcionalidades estritamente necessárias no momento presente, evitando a complexidade desnecessária e o desperdício de tempo e recursos na criação de recursos que podem nunca ser utilizados.

O princípio DRY sugere que as informações no código devem ser armazenadas em um único local e que cada parte do código deve ter uma única fonte de verdade, para evitar a duplicação de código e a inconsistência de informações.

KISS - Keep it simple, stupid

O princípio KISS ("Keep It Simple, Stupid", ou "Mantenha Simples, Estúpido") é um princípio de design onde a solução mais simples é muitas vezes a melhor. O princípio KISS pode ser aplicado a uma ampla gama de áreas, desde design de produtos até programação de computadores e gestão de projetos.

A ideia por trás do princípio KISS é que a simplicidade é a chave para criar soluções eficazes e eficientes. Soluções complexas podem ser difíceis de entender, implementar e manter, enquanto soluções simples são mais fáceis de entender e utilizar.

O princípio KISS não significa que as soluções devem ser simplistas ou superficiais, mas sim que devem ser mantidas o mais simples possível, eliminando tudo o que é desnecessário e mantendo apenas as funcionalidades essenciais.

Em resumo, a simplicidade é a chave para criar soluções eficazes e eficientes, e que devemos sempre procurar manter as coisas simples e diretas, evitando a complexidade desnecessária sempre que possível.

// Exemplo não KISS
function calcularMedia(listaDeNumeros) {
  let total = 0
  for (let i = 0; i < listaDeNumeros.length; i++) {
    total += listaDeNumeros[i]
  }
  return total / listaDeNumeros.length
}

// Exemplo KISS
function calcularMedia(listaDeNumeros) {
  const soma = listaDeNumeros.reduce((total, num) => total + num)
  return soma / listaDeNumeros.length
}

A função calcularMedia foi simplificada usando o método reduce() em vez de usar um loop for para somar os elementos da lista. Isso torna o código mais simples e fácil de entender.

YAGNI - You Aren't Gonna Need It

O princípio YAGNI ("You Ain't Gonna Need It", ou "Você Não Vai Precisar Disso") é um princípio que diz que não devemos adicionar funcionalidades que não são estritamente necessárias no momento presente. O objetivo do princípio é evitar a complexidade desnecessária e o desperdício de tempo e recursos na criação de recursos que podem nunca ser utilizados.

Seguindo o princípio YAGNI, os desenvolvedores devem focar nas funcionalidades essenciais e evitar adicionar recursos extras que possam ser úteis no futuro, mas que não são necessários no momento presente. Esses recursos extras podem incluir código redundante, bibliotecas desnecessárias ou recursos de interface de usuário que não são críticos para a funcionalidade principal.

// Exemplo não YAGNI
function calcularMedia(listaDeNumeros) {
  if (listaDeNumeros.length > 0) {
    let total = 0
    for (let i = 0; i < listaDeNumeros.length; i++) {
      total += listaDeNumeros[i]
    }
    return total / listaDeNumeros.length
  } else {
    return 0
  }
}

// Exemplo YAGNI
function calcularMedia(listaDeNumeros) {
  if (listaDeNumeros.length > 0) {
    const soma = listaDeNumeros.reduce((total, num) => total + num)
    return soma / listaDeNumeros.length
  }
  return 0
}

A função calcularMedia foi simplificada, removendo o código desnecessário que tratava o caso em que a lista de números estivesse vazia. Isso reduz a complexidade e torna o código mais fácil de ler.

DRY - Don't repeat yourself

O princípio DRY ("Don't Repeat Yourself", ou "Não Se Repita") é um princípio que sugere que as informações no código devem ser armazenadas em um único local e que cada parte do código deve ter uma única fonte de verdade. O objetivo do princípio DRY é reduzir a duplicação de código e evitar a inconsistência de informações, o que pode levar a problemas de manutenção e a bugs no software.

Seguindo o princípio, os desenvolvedores devem evitar copiar e colar código sem modificá-lo, em vez disso, eles devem criar funções, classes ou bibliotecas que possam ser reutilizadas em todo o código. Ao fazer isso, o código se torna mais fácil de manter e atualizar, já que as mudanças precisam ser feitas em apenas um lugar.

// Exemplo não DRY
function somar(a, b) {
  console.log(`A soma de ${a} e ${b} é ${a + b}`)
}

function subtrair(a, b) {
  console.log(`A subtração de ${a} e ${b} é ${a - b}`)
}

function multiplicar(a, b) {
  console.log(`A multiplicação de ${a} e ${b} é ${a * b}`)
}

function dividir(a, b) {
  console.log(`A divisão de ${a} e ${b} é ${a / b}`)
}

// Exemplo DRY
function operacao(a, b, operador) {
  let resultado
  switch (operador) {
    case '+':
      resultado = a + b
      break
    case '-':
      resultado = a - b
      break
    case '*':
      resultado = a * b
      break
    case '/':
      resultado = a / b
      break
    default:
      console.log('Operador inválido')
      return
  }
  console.log(`O resultado da operação ${operador} entre ${a} e ${b} é ${resultado}`)
}

A função operacao foi criada para evitar a duplicação de código que estava presente nas funções de soma, subtração, multiplicação e divisão. Ao passar um operador para a função operacao, é possível realizar qualquer uma dessas operações.

Conclusão

Esses princípios ajudam os desenvolvedores a escrever código mais limpo, claro e fácil de entender, e a criar software mais eficiente e fácil de manter ao longo do tempo.

Referências

UI2Code

Autor

Hemerson Vianna

github: ui2code

twitter: ui2code

Artigos relacionados