Validador de Regex de SSN em Go

O que é Regex de SSN?

Em Go (ou Golang), as expressões regulares são tratadas pelo pacote regexp embutido, permitindo que desenvolvedores correspondam e validem texto com precisão.

Um Social Security Number (SSN) nos EUA tem um formato fixo: AAA-GG-SSSS, onde:

• AAA é o número de área (3 dígitos)

• GG é o número de grupo (2 dígitos)

• SSSS é o número de série (4 dígitos)

Para validar essa estrutura, regex oferece uma solução simples e eficiente usando o padrão:

^\d{3}-\d{2}-\d{4}$

Este padrão garante:

• Três dígitos

• Seguidos de um hífen

• Depois dois dígitos

• Outro hífen

• E quatro dígitos finais

Aceitando SSNs Mascarados

Às vezes, você pode encontrar o formato com Xs, frequentemente usado para mascarar SSNs reais por privacidade ou em testes. Para acomodar tanto formas padrão quanto mascaradas, você pode usar:

^(\d{3}-\d{2}-\d{4}XXX-XX-XXXX)$

Isso corresponde a um SSN numérico válido ou à variante completamente mascarada.

Validação de SSN Mais Precisa

Embora o padrão acima cubra a estrutura básica, SSNs do mundo real têm regras adicionais. Certos valores são inválidos, como números de área 000, 666 ou qualquer número iniciando com 9, número de grupo 00 ou número de série 0000. Para uma validação mais rigorosa, considere:

^(?!(0006669))\d{3}-(?!00)\d{2}-(?!0000)\d{4}$

Este padrão impede esses blocos inválidos enquanto ainda corresponde ao formato SSN.

Suportando Entrada Flexível

Se você quiser permitir hifens opcionais ou suportar tanto "X" maiúsculo quanto minúsculo em SSNs mascarados, você pode usar:

^(\d{3}-?\d{2}-?\d{4}[Xx]{3}-?[Xx]{2}-?[Xx]{4})$

Ou, para simplificar, adicione a flag case-insensitive quando sua linguagem suportar.

Resumo

• Use para SSNs estritamente numéricos.

• Use para permitir formas mascaradas.

• Para validação mais robusta, use o padrão com lookaheads negativos.

• Ajuste para mascaramento e flexibilidade conforme necessário pela sua aplicação.

Expressões regulares oferecem uma maneira prática de lidar com validação de SSN, mas lembre-se de que as regras de negócio podem variar e verificações adicionais podem ser necessárias dependendo do seu caso de uso.

Exemplos de Entradas

Para ajudar você a visualizar o que esse regex captura e o que ignora, aqui estão algumas entradas no formato SSN e seus resultados:

• ✔️ Formato SSN válido

• ✔️ Válido, mas com espaços em vez de hifens

• ✔️ Formato SSN válido

• ❌ Inválido, contém letras

• ✔️ Válido, mas pode estar em faixas restritas de SSN

• ✔️ Padrão válido, mas não é um SSN real

• ❌ Inválido, número de área não pode ser 000

Essa variedade garante que seus testes possam distinguir entre SSNs corretamente formatados, erros comuns de entrada e entradas claramente inválidas. Use esses exemplos para ajustar sua validação ou para alimentar dados de teste realistas durante o desenvolvimento.

Entendendo Flags de Regex

Ao trabalhar com expressões regulares em Go ou JavaScript, você frequentemente vai encontrar flags que modificam o comportamento dos seus padrões. Aqui está uma referência rápida para as mais comuns:

• g (global): Busca todas as correspondências no texto, não apenas a primeira.

• i (ignorar maiúsculas/minúsculas): Torna a correspondência case-insensitive, tratando letras maiúsculas e minúsculas como iguais.

• m (multilinha): Muda o comportamento de ^ e $ para corresponder ao início e fim de cada linha, em vez de apenas o início e fim da string.

• s (dotAll): Permite que o ponto (.) corresponda a caracteres de nova linha, permitindo que seu padrão abranja múltiplas linhas.

• u (unicode): Habilita correspondência Unicode completa, facilitando o tratamento de emojis e caracteres de scripts não latinos.

• y (sticky): Corresponde apenas no último índice onde a correspondência anterior terminou, útil para iterar por uma string uma correspondência de cada vez.

Cada flag adapta seu regex para necessidades específicas de validação ou busca, então vale a pena experimentar para encontrar qual combinação se encaixa melhor no seu caso de uso.

Como SSNs Inválidos São Bloqueados

Nem todas as combinações são válidas para Social Security Numbers dos EUA, e o padrão regex é inteligente o suficiente para capturar formatos inválidos comuns. Veja como ele se defende contra entradas falsas:

• Sem Grupos Todo-Zero: O regex não aceita SSNs onde um grupo inteiro é zerado, como 000, 00 ou 0000. Isso protege contra placeholders e números irreais.

• Sem Início com 666: Qualquer SSN começando com 666 é sempre rejeitado, pois essa sequência nunca é atribuída a SSNs reais.

• Sem Faixas 900-999: O padrão também exclui SSNs começando com 900 a 999, que são reservados e não válidos para identificação padrão.

Com essas verificações, você minimiza o risco de processar SSNs obviamente falsos ou reservados, ajudando suas aplicações e endpoints de API a permanecerem seguros e confiáveis.

Padrão para SSNs Reais e Mascarados

E se você precisar aceitar tanto SSNs genuínos quanto placeholders mascarados (usando Xs)? Isso é comum ao lidar com dados redigidos por razões de privacidade ou entradas de placeholder durante testes.

Você pode alcançar isso expandindo sua expressão regular para tratar SSNs totalmente numéricos ou aqueles com Xs no lugar de números. Por exemplo, veja como você pode construir esse padrão:

• Corresponder SSNs padrão: ^\d{3}-\d{2}-\d{4}$

• Corresponder SSNs mascarados: ^X{3}-X{2}-X{4}$

Para permitir qualquer formato, combine-os usando o operador OR no seu regex. Para ainda mais flexibilidade, você pode tornar seu regex case-insensitive se quiser aceitar "x" minúsculo assim como "X" maiúsculo. Este padrão garante que apenas SSNs totalmente numéricos ou totalmente mascarados sejam aceitos, nunca uma mistura de números e Xs dentro da mesma correspondência.

Indo Além do Básico: Validação de SSN Mais Precisa

No entanto, se você quiser que sua validação seja mais do que apenas verificação de formato, há regras adicionais sobre o que constitui um SSN válido. Por exemplo, certos números não são emitidos:

• O número de área (AAA) não pode ser "000", "666" ou qualquer valor começando com "9".

• O número de grupo (GG) não pode ser "00".

• O número de série (SSSS) não pode ser "0000".

Para capturar essas regras extras e evitar a maioria dos SSNs inválidos, você pode usar um regex mais preciso:
^(?!(0006669))\d{3}-(?!00)\d{2}-(?!0000)\d{4}$
Este padrão aprimorado ajuda a filtrar SSNs obviamente inválidos enquanto mantém toda a lógica de validação em um único lugar.
Use o regex que melhor se adequa às suas necessidades: validação simples de formato ou conformidade mais rigorosa com as regras reais de atribuição de SSN.

Personalizando o Regex para SSNs Amigáveis a Testes

Às vezes, você precisa de SSNs para testes que não usam dados reais. Muitas equipes preferem usar placeholders "X" em vez de dígitos, como XXX-XX-XXXX. Para acomodar isso, você pode expandir o regex para permitir dígitos ou Xs em cada seção. Veja como funciona:

• Use \d{3}-\d{2}-\d{4} para corresponder a um SSN numérico padrão.

• Use [Xx]{3}-[Xx]{2}-[Xx]{4} para corresponder a um SSN totalmente preenchido com "X" (aceitando tanto maiúsculo quanto minúsculo).

Importante: Para manter sua validação rigorosa e evitar misturar "X"s e dígitos dentro do mesmo SSN (como 12X-4X-98X3), o regex deve aplicar um estilo ou outro, não uma mistura.

O padrão combinado permite um SSN totalmente numérico ou um com todos "X"s no lugar dos dígitos, mas nunca uma mistura em posições diferentes. Se quiser aceitar apenas "X"s para placeholders, use o padrão [Xx]{3}-[Xx]{2}-[Xx]{4}.

Como Suportar SSNs Mascarados no Seu Regex

Às vezes, você precisa acomodar Social Security Numbers mascarados, onde alguns ou todos os dígitos são substituídos por "X" ou "x" por privacidade (por exemplo, "XXX-XX-9023" ou "xxx-xx-xxxx"). Para tratar isso, a expressão regular deve reconhecer um SSN totalmente numérico ou uma versão onde cada seção pode ser substituída por Xs.

Veja como você pode expandir seu regex para permitir ambos os formatos:

• SSN numérico completo: 123-45-6789

• Totalmente mascarado: XXX-XX-XXXX (também aceita "x" minúsculo)

• Nota: Cada segmento deve ser todo dígitos ou todo Xs.

Dicas Rápidas:

• Para ainda mais flexibilidade, adicione correspondência case-insensitive se sua ferramenta suportar.

• Evite misturar dígitos e Xs dentro de qualquer segmento único para manter formatação e segurança consistentes.

Agora seu validador baseado em Go está pronto para reconhecer SSNs reais e mascarados, facilitando o teste, anonimização ou exibição de dados sensíveis com segurança.

Combinando Múltiplos Formatos de SSN em um Único Regex

Às vezes, você precisa de um regex que cubra mais de uma estrutura padrão de SSN. Por exemplo, talvez sua aplicação aceite tanto SSNs validamente formatados (como 123-45-6789) quanto valores de placeholder (como XXX-XX-XXXX), que são comuns em testes, mascaramento de dados ou conjuntos de dados de exemplo.

Para capturar ambas as possibilidades em um único padrão, você pode usar um OR lógico no seu regex. O padrão corresponde a:

• SSNs com dígitos corretamente formatados (por exemplo, 111-22-3333)

• Versões de placeholder usando X maiúsculo ou minúsculo (por exemplo, XXX-XX-XXXX ou xxx-xx-xxxx)

Você pode até estender o regex tornando-o case-insensitive. No pacote regexp do Go, os padrões são sempre case-sensitive, então você precisaria de [Xx] em vez de apenas X.

Resumo da lógica do padrão:

• \d{3}-\d{2}-\d{4}: Corresponde ao formato padrão de SSN.

• [Xx]{3}-[Xx]{2}-[Xx]{4}: Corresponde a um placeholder anonimizado em minúsculo ou maiúsculo.

Se o seu caso de uso tiver variações adicionais (por exemplo, hifens opcionais), você pode ajustar o regex para incluir -? após cada bloco numérico ou de X. Para a maioria dos fluxos de trabalho de validação que cobrem dados reais e fictícios, o padrão acima fornece uma solução robusta.

Correspondendo a Qualquer Padrão 3-2-4 com Hifens

Às vezes, você pode querer validar entradas que usam o mesmo formato 3-2-4 de um SSN, mas sem ser restrito apenas a dígitos. Para permitir qualquer caractere exceto hifens nessas posições, você pode usar uma expressão regular flexível:

Veja como este padrão funciona:

• [^-]{3}: Exatamente três caracteres, cada um que não seja um hífen (-)

• -: Um hífen literal como separador

• [^-]{2}: Mais dois caracteres, novamente qualquer coisa exceto hífen

• -: Outro hífen literal

• [^-]{4}: Quatro caracteres finais, nenhum dos quais é hífen

Esta estrutura corresponde a qualquer string que siga um padrão 3-2-4 separado por hifens, sejam letras, símbolos ou números (desde que não sejam hifens).

Exemplos de correspondências:

• abc-de-fghi

• 1a2-34-5678

• XYZ-tt-9*1!

Lembre-se: Isso permite correspondências amplas. Use apenas se você realmente quiser aceitar qualquer caractere exceto hífen nessas posições.

Recursos e Benefícios Principais

• Formato Específico: Aplica estritamente o formato de SSN dos EUA.

• Validação Instantânea: Funciona imediatamente em Go com regexp.MustCompile.

• Teste Seguro: Evite usar dados reais, teste seus sistemas com valores fictícios.

• Regex Reutilizável: Incorpore facilmente este padrão na sua base de código Go.

• Compatível com Múltiplas Ferramentas: Funciona muito bem com Gerador de UUID, Gerador de MAC Address e Validador de Regex de Número de Telefone em Go para simulação completa.

Exemplo de Código em Go

package main
import (
"fmt"
"regexp"
)
func isValidSSN(ssn string) bool {
// Regex for U.S. SSN: 3 digits - 2 digits - 4 digits
var ssnRegex = regexp.MustCompile(^\d{3}-\d{2}-\d{4}$)
return ssnRegex.MatchString(ssn)
}
func main() {
testSSN := "123-45-6789"
fmt.Printf("Is '%s' a valid SSN? %t\n", testSSN, isValidSSN(testSSN))
}

Tornando Seu Regex Case-Insensitive

Para corresponder a "X" maiúsculo e minúsculo em SSNs mascarados, como "XXX-XX-1234" ou "xxx-xx-1234", você tem duas opções:

• Inclua ambos os casos no seu padrão com [Xx] onde quer que a máscara apareça.

• Use a flag case-insensitive (i), se o seu contexto de regex em Go suportar.

Para o pacote regexp do Go, você precisará especificar [Xx] no regex, pois o Go não suporta uma flag case-insensitive inline. Isso garante que sua validação cubra todos os formatos comuns de SSN mascarado sem perder nenhum.

Dicas Pro para Usar Regex de SSN em Go

• Use Âncoras para Correspondência Completa: Sempre envolva seu regex com ^ e $ para garantir que toda a string seja validada, não apenas uma substring.

• Evite Dados Reais em Testes: Nunca use SSNs reais em ambientes de teste. Em vez disso, simule-os usando ferramentas como o Gerador de Nome de Usuário, Gerador de Número de Telefone ou Gerador de Endereço para criar perfis completos de simulação.

• Pré-compile para Performance: Use regexp.MustCompile() fora de loops ou funções para pré-compilar seu regex e melhorar a performance, especialmente em aplicações de grande escala.

• Valide o Formato, Não a Identidade: Regex verifica apenas a estrutura. Para validar SSNs reais, integre com uma API de verificação ou banco de dados oficial.

• Use Logging para Depuração: Ao testar sua lógica de regex em Go, adicione logs para rastrear correspondências e não-correspondências. Isso ajuda a identificar problemas de formatação cedo.

Indo Além da Validação Básica

Embora um padrão simples cubra a maioria das necessidades de formatação, ele não captura todas as regras que tornam um SSN verdadeiramente válido. Para uma validação mais robusta, considere um regex mais rigoroso:

^(?!(0006669))\d{3}-(?!00)\d{2}-(?!0000)\d{4}$

Este padrão adiciona restrições do mundo real:

• Sem números de área começando com 000, 666 ou 9xx.

• Sem números de grupo iguais a 00.

• Sem números de série iguais a 0000.

Consultar fontes como as diretrizes da SSA pode ajudar a garantir que sua lógica de validação siga os padrões oficiais. Lembre-se, essas restrições tornam sua validação mais forte, mas ainda não garantem que o número foi atribuído ou pertence a uma pessoa real.

Se você precisar suportar dados de teste óbvios, você também pode expandir seu padrão para incluir valores fictícios comuns além da validação de formato do mundo real.

Casos de Uso Comuns

• Validação de Formulários: Garanta que os usuários insiram SSNs no formato correto.

• Sistemas de Onboarding: Verifique identificação durante o cadastro de usuários.

• Limpeza de Dados: Limpe e padronize campos de SSN no seu banco de dados.

• Sistemas de Conformidade: Aplique validação de formato para fluxos de trabalho sensíveis à privacidade.

Você também vai encontrar esses conceitos básicos de regex úteis:

Expressão: correspondência a qualquer dígito (equivalente a [0-9]). Para a palavra "hello" repetida de 1 a 3 vezes consecutivas. O início de uma linha ou string. O fim de uma linha ou string. Esses elementos são essenciais ao criar padrões para corresponder SSNs ou quaisquer dados estruturados em suas aplicações Go.

Combine com Estas Ferramentas

Use o Validador de SSN com essas ferramentas do Qodex para simulação e testes completos de perfil:

• Gerador de Número de Telefone - Gere números dos EUA para combinar com SSNs.

• Gerador de Endereço - Crie endereços fictícios, mas realistas, dos EUA para dados de usuário simulados.

• Gerador de E-mail - Construa perfis de usuário completos para testes de formulários.

• Gerador de UUID - Atribua identificadores únicos a cada usuário simulado.

• Gerador de MAC Address - Útil para simular identidade baseada em dispositivo.

• Regex Tester para Go - Valide qualquer padrão diretamente nas suas aplicações Go.

Regex para Outras Linguagens

Quer testar SSNs em outras linguagens?

• JavaScript: Use no JavaScript Regex Tester

• Python: Experimente no Python Regex Tester

• Java: Valide no Java Regex Tester