O que é remover pontos e traços na prática
Remover pontos e traços é basicamente uma operação de limpeza de strings. Você pega um texto que tem caracteres como ".", "-", "_", ou espaços extras e devolve uma versão enxuta, geralmente juntando tudo em uma palavra só. Parece simples até você se deparar com um arquivo CSV de 50 mil linhas gerado por um sistema legado e perceber que o "simples" demora dois dias para rodar. No JavaScript, a forma mais direta é usar replace com regex. Algo como str.replace(/[\.\-_]+/g, '') resolve para a maioria dos casos. Mas o problema real aparece quando o texto vem de fontes externas — formulários HTML, arquivos exportados, APIs que não validam nada. Aí você descobre que tem caracteres invisíveis, encontros de acentos estranhos, e às vezes até quebras de linha no meio do dado.
Como fazer remover pontos e traços em JavaScript
O código mais comum que você vai encontrar é esse: const limpo = texto.replace(/[^\w\s-]/g, '').replace(/\s+/g, '');
Isso remove pontuação e depois junta os espaços. O problema é que \w inclui sublinhado, então se o seu objetivo é exatamente remover pontos e traços mas manter sublinhados, a regex precisa ser ajustada. A versão que eu uso atualmente é texto.replace(/[\.\-]/g, '').trim(). Mais direta, menos surpresas. Para lidar com casos mais difíceis — múltiplos caracteres repetidos, espaços duplos, hífen em diferentes formas Unicode — eu acabei adotando uma função que normaliza primeiro:
function clean(text) { return text.normalize('NFKD').replace(/[\.\-]/g, '').replace(/\s+/g, ' ').trim(); } A chamada normalize('NFKD') transforma caracteres compostos em suas partes básicas. Um "é" vira "e" mais um acento cedilha separado. Depois o replace corta o que você quer. Isso resolve um bug que eu tive há uns dois anos atrás com nomes de usuários vindos de um formulário espanhol que tinha hífen tipo "–" (en-dash) em vez do hífen tradicional "-". A regex simples não pegava e o dado entrava corrompido no banco.
Edge case que eu levei golpe
Eu estava processando uma lista de códigos de produto importados de um ERP antigo. Os códigos vinham com pontos e traços misturados, tipo "BR-123.456-78". A regex que eu tinha funcionava perfeitamente em teste. Nos dados reais, alguns campos vinham com Zero Width Space (U+200B) escondido. O replace clássico ignorava completamente esse caractere, e o resultado era um campo que parecia certo mas tinha um byte invisível no meio. Quando o sistema downstream tentava fazer lookup, falhava silenciosamente. Eu gastei três horas debugando antes de perceber que o problema não era a regex, mas a entrada suja. A solução foi adicionar .replace(/[\u200B-\u200D\uFEFF]/g, '') no pipeline de limpeza, explicitamente removendo os caracteres de largura zero.
Remover pontos e traços em Python
Em Python o caminho mais usual é o método translate do str, que é significativamente mais rápido que replace em lote para textos grandes. O truque é construir uma tabela de tradução com str.maketrans: import string
table = str.maketrans('', '', '.-') texto_limp = texto.translate(table)
👉 Clique no botão abaixo para saber mais sobre o assunto!
Se precisar também de normalização de espaços, encadeia-se um split e join: ' '.join(texto_limp.split()). Para textos acima de 100 mil caracteres, essa abordagem costuma ser de 3 a 5 vezes mais rápida que usar re.sub repetidamente, dependendo do hardware. Um detalhe importante: translate trabalha com caracteres individuais. Se você precisa remover sequências inteiras como "--" ou "..." como unidade, aí volta pro módulo re. Mas na prática, na maioria dos casos de remover pontos e traços, translate basta.
Remover pontos e traços em SQL
Em SQL a coisa fica mais chata porque as funções de string variam entre bancos. No PostgreSQL, o mais prático é: SELECT regexp_replace(campo, '[.\-]', '', 'g') FROM tabela;
No MySQL seria: SELECT REPLACE(REPLACE(campo, '.', ''), '-', '') FROM tabela;
O problema com MySQL é que você precisa encadear REPLACE para cada caractere que quer remover. Para muitos caracteres diferentes, isso fica verboso e difícil de manter. Nesse caso, eu prefiro fazer a limpeza no código da aplicação antes de salvar, porque fica mais legível e você pode adicionar logs de transformação sem afetar a query.
Pegadinhas que ninguém conta
Primeiro, remover pontos e traços pode destruir dados que precisam ser preservados. CPF, CNPJ, placas de carro, códigos de rastreio — todos usam esses caracteres como parte da formatação oficial. Se você aplicar uma limpeza agressiva sem verificar o contexto, vai transformar "AB3-456CD" em "AB3456CD" e quebrar validações posteriores. Sempre pense no que é identificador vs. o que é texto livre antes de limpar. Segundo, a normalização Unicode nem sempre é segura. A função normalize do JavaScript, por exemplo, pode transformar "" (liga de f + i) em "fi". Isso é bom na maioria dos casos, mas se o seu sistema trata strings como tokens exatos — tipo chaves de API ou senhas — a normalização muda o valor original e gera colisões. Nesses cenários, evite normalize e vá direto no replace dos caracteres-alvo.
Terceiro, performance em escala. Eu processei uma vez um arquivo de 2 GB com milhões de linhas. A abordagem ingênua de loop com replace simples levou cerca de 47 minutos. Trocar para translate em Python reduziu para 6 minutos. Em JavaScript, usar replace com regex compilada uma única vez (fora do loop) em vez de recompilar a cada iteração cortou o tempo de 23 minutos para 4. Não é mágica, é apenas evitar trabalho desnecessário.
Quando essa abordagem simplesmente não funciona
Remover pontos e traços com regex padrão não resolve se o seu problema é limpeza semântica. Um endereço como "Rua das Flores, 123 - Centro" pode ter o traço removido e virar "Rua das Flores, 123 Centro", que ainda assim não é um dado útil para lookup geográfico. A limpeza de caracteres é só o primeiro passo. O segundo — e onde a maioria dos projetos trava — é entender o que aquele texto representa e tratar de acordo. Se você está lidando com dados de entrada do usuário em produção, o ideal é combinar a remoção de caracteres com validação estrutural. Verifique o formato esperado antes de aplicar qualquer transformação. Uma regex que valida um CPF tem mais valor do que três replaces encadeados que limpam cega e destrutivamente.
Resumo funcional
O conhecimento de remover pontos e traços é útil, mas limitado. Use translate para performance em Python, regex com normalize para JavaScript quando os dados forem sujos, e SQL nativo do seu banco quando a limpeza tiver que ficar no banco mesmo. Valide o contexto antes de limpar. E não confie cegamente em resultados que parecem certos — caracteres invisíveis e forms de hífen variados vão te pegar se você não especificar o que exatamente está removendo.
