Função Auxiliar De Limpeza

Função auxiliar de limpeza: o que ela faz na prática

Uma função auxiliar de limpeza é aquele pedaço de código que você chama antes de processar qualquer dado que vem do usuário, de uma API externa ou de um arquivo mal formatado. O objetivo é simples: transformar strings sujas em algo que seu sistema consome sem quebrar. Nada mais, nada menos. A maioria dos desenvolvedores Sublime Text ou VS Code que eu conheço escreve uma dessas para cada projeto novo, porque ninguém gosta de tratar `undefined` em produção.

Implementando uma função auxiliar de limpeza

Vamos ao que importa. Aqui está uma versão funcional que eu uso em projetos Node.js há anos:

function sanitizeInput(input) {
  if (typeof input !== 'string') return input;
  
  return input
    .trim()
    .replace(/\s+/g, ' ')
    .replace(/[<>\"'&]/g, (match) => {
      const entities = {
        '&': '&',
        '<': '<',
        '>': '>',
        '"': '"',
        "'": '''
      };
      return entities[match];
    });
}

Isso remove espaços extras no início e no final, compacta múltiplos espaços em um só e escapa caracteres que podem causar problemas de injeção. É o básico que funciona na maior parte dos casos. Mas existem armadilhas que ninguém menciona em tutoriais. O primeiro erro comum é pensar que sanitização substitui validação. Uma função auxiliar de limpeza não verifica se o dado é válido, ela apenas limpa o que chegou. Se você passar um número onde espera uma string, ela vai retornar `undefined` ou fazer casting silencioso, e seu código pode continuar rodando com dados errados. Separe sempre: valide primeiro, limpe depois. E lembre-se de validar o tipo antes de aplicar os métodos de string.

O segundo erro é confiar demais em bibliotecas prontas. Eu já vi gente usar `DOMPurify` para sanitizar campos que jamais serão renderizados em HTML. Isso adiciona um overhead desnecessário e aumenta o tamanho do bundle. Para limpar strings que vão para banco de dados ou processamento interno, uma regex simples é mais rápida e suficiente. Use a ferramenta certa para o contexto. Aqui vai um caso real que eu encontrei na última semana: estava tratando um campo de CEP que vinha com hífen, espaços e formatação irregular de um formulário legado. A função padrão de limpeza quebrei porque a regex de escape de entidades HTML entrava em conflito com a remoção de caracteres especiais. A solução foi separar em duas etapas: primeiro normalizar o formato (remover tudo que não for número e manter exatamente 8 dígitos), depois aplicar a sanitização geral. Ficou assim:

function sanitizeCEP(cep) {
  if (typeof cep !== 'string') return null;
  const digits = cep.replace(/\D/g, '').slice(0, 8);
  if (digits.length !== 8) return null;
  return digits;
}

Esse tipo de função específica para cada domínio é mais confiável do que tentar generalizar tudo numa única função. Você ganha clareza e perde tempo evitando bugs que aparecem só em produção.

Limitações que ninguém conta

Funções auxiliares de limpeza têm um ponto fraco claro: elas não resolvem problemas de integridade de dados estruturais. Se o formato do dado muda (um campo que era string vira objeto, por exemplo), sua função pode falhar silenciosamente. Sempre adicione logging ou return type assertivo. Em TypeScript, usar tipos estritos como `string | null` ao invés de `any` evita que dados corrompidos passem despercebidos. Outro problema é performance. Se você está limpando milhões de registros de uma vez, cada replace e regex adicional soma tempo. Na minha experiência, funções de limpeza bem escritas processam cerca de 50 mil strings por segundo em um servidor médio. Se o volume for maior, considere processamento em batch ou streaming, não aplicar a função em loop simples.

O conselho prático: não tente fazer uma função universal. Escreva funções específicas para cada tipo de dado que seu sistema recebe. Isso reduz bugs, facilita testes e torna o código mais legível para quem for dar manutenção depois.