Clean Code em JavaScript: princípios de escrita de código limpo

Clean Code em JavaScript: princípios e exemplos

Código limpo (Clean Code) não é apenas um termo da moda, mas uma abordagem fundamental para o desenvolvimento que torna o programa compreensível, fácil de manter e extensível. No mundo do JavaScript e Node.js, onde os projetos crescem rapidamente e exigem mudanças frequentes, os princípios do Clean Code tornam-se especialmente importantes. Neste artigo, vamos analisar as principais práticas de escrita de código limpo em JavaScript com exemplos concretos que ajudarão você a melhorar a qualidade dos seus projetos.

1. Nomenclatura correta de variáveis e funções

O nome de uma variável ou função deve responder às perguntas "o que é isso?" e "o que faz?". Evite nomes de uma única letra (exceto contadores de loop) e abreviações que não sejam óbvias.

Exemplo ruim:

const d = new Date();const a = [];const fn = (x, y) => x + y;

Exemplo bom:

const currentDate = new Date();const userList = [];const calculateSum = (firstNumber, secondNumber) => firstNumber + secondNumber;

Regras de nomenclatura:

• Use camelCase para variáveis e funções.
• Para valores booleanos, use prefixos: is, has, should (por exemplo, isActive, hasPermission).
• Nomeie funções com verbos: getUser, sendEmail, validateInput.
• Evite abreviações: usr → user, conf → configuration.

2. Funções pequenas e de tarefa única

Cada função deve executar exatamente uma tarefa. Se uma função faz mais de uma ação, ela precisa ser dividida em várias. Isso melhora a legibilidade e a testabilidade.

Exemplo ruim (função faz 3 coisas de uma vez):

function processUserData(user) {  // Validação  if (!user.email || !user.password) {    throw new Error('Invalid data');  }  // Formatação  const formattedUser = {    email: user.email.toLowerCase(),    password: hashPassword(user.password)  };  // Salvamento no BD  db.save(formattedUser);  return formattedUser;}

Exemplo bom (divisão em funções separadas):

function validateUserInput(user) {  if (!user.email || !user.password) {    throw new Error('Email and password are required');  }}

function formatUserData(user) {  return {    email: user.email.toLowerCase(),    password: hashPassword(user.password)  };}

function saveUserToDatabase(user) {  return db.save(user);}

function processUserData(user) {  validateUserInput(user);  const formattedUser = formatUserData(user);  return saveUserToDatabase(formattedUser);}

Essa abordagem torna o código autodocumentado e simplifica a localização de erros.

3. Tratamento de erros e casos limite

Código limpo obrigatoriamente inclui tratamento de erros e prevê casos limite. Não deixe espaço para falhas inesperadas.

Exemplo ruim (sem tratamento de erros):

function getUserAge(user) {  return user.age; // Se user ou user.age for undefined — erro}

Exemplo bom (com proteção):

function getUserAge(user) {  if (!user || typeof user.age !== 'number') {    return null; // ou throw new Error('Invalid user data')  }  return user.age;}

Princípios de tratamento de erros:

• Use try/catch para operações assíncronas (especialmente em Node.js).
• Crie classes de erro próprias para diferentes situações.
• Não engula erros silenciosamente — registre-os ou propague-os adiante.

class ValidationError extends Error {  constructor(message) {