Validador de Regex de SSN em Javascript

O que é um Regex de SSN?

Nos EUA, um Social Security Number (SSN) é um número de 9 dígitos formatado como XXX-XX-XXXX. Validar esse formato é crucial em aplicações onde verificação de identidade ou precisão de entrada de dados é necessária.

Uma expressão regular (regex) ajuda a garantir que o formato esteja correto antes que qualquer operação sensível seja realizada.

Padrão Regex Comum para SSN

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

O que Este Padrão Faz:

• ^\d{3}: Começa com exatamente 3 dígitos

• -: Um hífen

• \d{2}: Seguido de 2 dígitos

• -: Outro hífen

• \d{4}$: Termina com 4 dígitos

SSN Válido: 123-45-6789

SSN Inválido: 12-3456-789 ou 123456789

Um Regex de SSN Mais Preciso

Embora o padrão acima corresponda ao formato padrão de SSN, ele não captura todas as possibilidades inválidas. Certas combinações, como números de área começando com 000, 666 ou 9, ou grupos como 00 ou 0000, não são válidos para Social Security Numbers reais.

Se você precisar de uma verificação mais rigorosa, considere este padrão:

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

O que Foi Melhorado Aqui:

• Garante que o número de área (os três primeiros dígitos) não seja 000, 666 ou qualquer número começando com 9.

• O número de grupo (dois dígitos do meio) não pode ser 00.

• O número de série (últimos quatro dígitos) não pode ser 0000.

Esta camada extra ajuda a filtrar SSNs obviamente inválidos enquanto ainda corresponde ao formato correto.

Exemplo de SSN válido: 123-45-6789
Exemplos de SSNs inválidos: 000-12-3456, 666-12-3456, 900-12-3456, 123-00-4567, 123-45-0000

Use o padrão mais rigoroso se quiser refletir mais de perto as regras reais de SSN, mas lembre-se: mesmo o melhor regex não pode garantir que um número está realmente atribuído a alguém.

Um Padrão Mais Flexível para Formatos Personalizados

Se você quiser um regex que corresponda a qualquer agrupamento de caracteres não-hífen seguindo a divisão 3-2-4 familiar (mas sem exigir dígitos), você pode ajustar o padrão assim:

Como Este Padrão Funciona:

• ^[^-]{3}: Começa com exatamente 3 caracteres que não são hifens

• -?: Um hífen opcional

• [^-]{2}: Próximos 2 caracteres não-hífen

• -?: Outro hífen opcional

• [^-]{4}$: Finalmente, 4 caracteres não-hífen

Isso é útil se você lida com códigos ou IDs, como ABC-DE-1234 ou XyZ12aBcd, que não são estritamente numéricos mas ainda se encaixam na estrutura 3-2-4 (com ou sem hifens).

Exemplos correspondentes:

• ABC-DE-1234

• xyz12abcd

• B2C-D1-42k7

Exemplos não correspondentes:

• AB-DE-1234 (apenas 2 caracteres no início)

• ABC--DE-1234 (contém hifens duplos)

• A-BC-DE-1234 (agrupamento incorreto)

Fique à vontade para ajustar os números se o seu formato variar!

Correspondendo a Formatos de SSN Numéricos e Mascarados

Se você quiser que seu regex aceite tanto SSNs numéricos padrão quanto os que usam caracteres 'X' para mascaramento (como XXX-XX-XXXX), basta expandir um pouco o seu padrão.

O que o Padrão Atualizado Faz:

• \d{3}-\d{2}-\d{4}: Corresponde a três dígitos, um hífen, dois dígitos, um hífen e quatro dígitos, como antes.

• [Xx]{3}-[Xx]{2}-[Xx]{4}: Corresponde a três Xs (maiúsculo ou minúsculo), um hífen, dois Xs, um hífen e quatro Xs.

• O operador OR permite corresponder à versão numérica ou mascarada, mas não uma mistura de ambas.

• O ^ e o $ correspondem ao início e fim da string para garantir que o SSN completo seja validado.

Exemplos

• SSN Numérico Válido: 123-45-6789

• SSN Mascarado Válido: XXX-XX-XXXX ou xxx-xx-xxxx

• Misto Inválido: 123-XX-6789

Com isso, você pode aceitar com confiança o SSN real ou o placeholder mascarado, sem preocupações com combinações indevidas!

Padrão Estrito: Permitindo Apenas 123-45-6789 ou XXX-XX-XXXX

Se você precisar de um regex que corresponda apenas aos SSNs específicos 123-45-6789 ou XXX-XX-XXXX:

• ^ e $ garantem que o padrão corresponda à string inteira do início ao fim.

• O operador OR permite qualquer um dos dois, nada mais.

Qualquer entrada além desses dois formatos exatos será rejeitada.

Combinando Múltiplos Formatos de SSN com Alternância

Suponha que você precise aceitar tanto SSNs padrão (apenas números) quanto formatos de placeholder (como todos Xs) no seu regex. É aqui que a alternância é útil. A alternância permite que seu regex corresponda a um padrão ou outro usando o caractere pipe.

Por exemplo, para permitir:

• SSNs numéricos padrão: 123-45-6789

• SSNs de placeholder: XXX-XX-XXXX

O símbolo OR significa "ou", então o regex corresponderá se a entrada se encaixar no padrão numérico ou no padrão de todos-X. Os parênteses agrupam as alternativas, garantindo que o regex corresponda à estrutura de qualquer opção do início ao fim.

Você pode adaptar ainda mais este padrão para permitir flexibilidade, como corresponder a "x" minúsculo com [Xx]. Use a flag i (para correspondência case-insensitive) se seu sabor de regex suportar, tornando as coisas ainda mais simples.

Permitindo Todos os Dígitos ou Todos os Xs (Mas Não Misturados) no Regex de SSN

Suponha que você queira que sua entrada de SSN aceite a versão padrão de todos os dígitos (123-45-6789) ou uma versão mascarada usando apenas Xs (XXX-XX-XXXX), mas nunca uma mistura dos dois. Veja como fazer isso:

Detalhamento do Regex

Para alcançar isso, use o operador OR e agrupe padrões para clareza:

• O primeiro padrão corresponde apenas a dígitos no formato SSN: ^\d{3}-\d{2}-\d{4}$

• O segundo padrão corresponde apenas a Xs (case-insensitive), mesmo formato: ^[Xx]{3}-[Xx]{2}-[Xx]{4}$

Combine-os. Ou, se sua linguagem suportar, você pode usar a flag case-insensitive (i) então só precisa de [X]{3}-[X]{2}-[X]{4}.

O que Isso Faz?

• Apenas dígitos permitidos: 123-45-6789

• Apenas Xs permitidos: XXX-XX-XXXX (aceita maiúsculas e minúsculas)

• Sem mistura: Padrões como 12X-4X-6789 não vão corresponder

Isso mantém as entradas consistentes e seguras, especialmente para formulários que mascaram informações sensíveis.

Dica: Para flexibilizar sobre hifens (por exemplo, hifens opcionais), substitua - por -? em ambas as alternativas.

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

Embora corresponder ao formato XXX-XX-XXXX seja um bom começo, um SSN verdadeiramente válido também deve atender a alguns critérios mais específicos:

• Apenas 9 Dígitos: O SSN deve ter exatamente 9 dígitos, nem mais, nem menos.

• Hifenizado em 3 Partes: O número é sempre dividido em três partes por hifens: a primeira parte (3 dígitos), a segunda parte (2 dígitos) e a terceira parte (4 dígitos).

• Restrições da Primeira Parte: Os três primeiros dígitos não podem ser 000, 666 ou qualquer número na faixa de 900 a 999.

• Faixa da Segunda Parte: Os dois dígitos do meio devem estar entre 01 e 99, o valor 00 não é válido.

• Faixa da Terceira Parte: Os últimos quatro dígitos devem estar entre 0001 e 9999, o valor 0000 não é válido.

Ao combinar formatação regex e essas regras adicionais, você pode validar SSNs com mais confiança e filtrar entradas inválidas ou potencialmente fraudulentas.

Considerações de Performance

Ao validar um SSN com este padrão regex, o processo examina cada caractere na string de entrada uma vez, tornando a complexidade de tempo linear, O(N), onde N é o número de caracteres. Os requisitos de espaço são mínimos, pois o mecanismo regex não precisa de memória extra proporcional ao tamanho da entrada. Em resumo, você obtém validação eficiente tanto em velocidade quanto em uso de memória.

Como Validar SSNs em JavaScript

Aqui está um exemplo completo de código JavaScript:

function isValidSSN(ssn) {
  const ssnRegex = /^\d{3}-\d{2}-\d{4}$/;
  return ssnRegex.test(ssn);
}
// Example usage:
console.log(isValidSSN("123-45-6789")); // true
console.log(isValidSSN("123456789"));   // false

Como Validar SSNs em Python

Precisa garantir que SSNs se encaixem no molde correto na sua aplicação Python? Aqui está uma abordagem fácil usando expressões regulares, ótima para verificações de backend ou migrações de dados.

Aqui está uma função típica para validar o formato de SSN em Python:

import re
def is_valid_ssn(ssn):
pattern = r"^(?!6660009\d{2})\d{3}-(?!00)\d{2}-(?!0000)\d{4}$"
return bool(re.match(pattern, ssn))

Como funciona:

• ^(?!6660009\d{2})\d{3}: O SSN não pode começar com 666, 000 ou qualquer número entre 900-999.

• -(?!00)\d{2}: Os dois dígitos do meio não podem ser 00.

• -(?!0000)\d{4}$: Os últimos quatro dígitos não podem ser 0000.

Exemplos:

print(is_valid_ssn("856-45-6789"))   # True – valid SSN
print(is_valid_ssn("000-45-6789"))  # False – invalid, leading block not allowed
print(is_valid_ssn("856-452-6789")) # False – wrong format
print(is_valid_ssn("856-45-0000"))  # False – trailing block not allowed

Esta abordagem filtra rapidamente a maioria dos problemas de formato de SSN e pode ser facilmente adaptada para processamento em lote ou validação de entrada do usuário. Para proteção extra, combine com soluções de armazenamento seguro, nunca mantenha SSNs à vista!

Como Validar SSNs Usando Regex em Java

Assim como em JavaScript, você também pode usar uma expressão regular em Java para verificar formatos de Social Security Number eficientemente.

Aqui está como uma função de validação típica se parece em Java:

import java.util.regex.Pattern;
public class SSNValidator {
// Pattern blocks obviously invalid ranges (000, 666, 900-999 in the first group; 00 in the middle; 0000 at the end)
private static final Pattern SSN_REGEX = Pattern.compile(
"^(?!6660009\d{2})\d{3}-(?!00)\d{2}-(?!0{4})\d{4}$"
);
public static boolean isValidSSN(String ssn) {
    if (ssn == null) return false;
    return SSN_REGEX.matcher(ssn).matches();
}

// Example usage
public static void main(String[] args) {
    System.out.println(isValidSSN("856-45-6789")); // true
    System.out.println(isValidSSN("000-45-6789")); // false
    System.out.println(isValidSSN("856-452-6789")); // false
    System.out.println(isValidSSN("856-45-0000")); // false
}

}

Como Funciona:

• O regex impede SSNs inválidos comuns, como os que começam com 666, 000 ou qualquer série 900-999, assim como entradas com todos os zeros no meio ou no fim.

• A função retorna true apenas se a entrada corresponder tanto ao formato SSN quanto a essas regras mais rigorosas.

• Sempre verifique se há null antes de tentar a correspondência para evitar exceções.

Esta abordagem fornece uma camada extra de segurança, capturando não apenas formatos digitados incorretamente, mas também valores explicitamente bloqueados pela Social Security Administration.

Onde o Regex de SSN Pode Ser Usado?

• Onboarding de Usuários: Garanta que usuários insiram SSNs válidos em aplicações financeiras ou de RH.

• Integridade de Banco de Dados: Capture erros de formato antes de salvar no banco de dados.

• Validação de Formulários: Bloqueie submissões que não seguem a estrutura esperada de SSN.

Use nosso JavaScript Regex Tester para experimentar variações ou criar padrões personalizados.

Como Validar SSNs em C#

Se você trabalha com .NET ou C#, também pode usar expressões regulares para aplicar formatação correta de SSN e filtrar números comuns de placeholder ou inválidos. Veja como implementar um validador robusto de SSN em C#:

using System.Text.RegularExpressions;
public static bool IsValidSSN(string ssn)
{
// This regex:
// - Prevents area numbers 666, 000, or anything starting with 9
// - Ensures group (middle) isn't 00, and serial (last four) isn't 0000
var pattern = @"^(?!6660009\d{2})\d{3}-(?!00)\d{2}-(?!0{4})\d{4}$";
return Regex.IsMatch(ssn, pattern);
}

Exemplo de uso:

var testSSNs = new[] { "856-45-6789", "000-45-6789", "856-452-6789", "856-45-0000" };
foreach (var s in testSSNs)
{
Console.WriteLine(IsValidSSN(s)); // Prints True or False
}

• "856-45-6789" - Válido (True)

• "000-45-6789" - Inválido (área não pode ser 000)

• "856-452-6789" - Inválido (formato incorreto)

• "856-45-0000" - Inválido (série não pode ser 0000)

Esta abordagem protege sua aplicação dos erros de entrada de SSN mais comuns e ajuda a manter seus dados de identidade mais limpos desde o início.

Validação de SSN em C++ Usando Regex

Se você trabalha em C++ e precisa garantir que Social Security Numbers sejam formatados corretamente, pode incorporar facilmente a validação de regex de SSN na sua base de código.

Aqui está uma abordagem prática:

1. Inclua as Bibliotecas Necessárias:
   Certifique-se de ter os cabeçalhos <regex> e <string> disponíveis.

2. Escreva a Função de Validação:
   Crie uma função que recebe a string do SSN e retorna se ela corresponde ao padrão padrão.

#include
#include
#include
// Checks if SSN matches the standard pattern
bool isValidSSN(const std::string& ssn) {
// Prevents invalid area, group, and serial numbers
std::regex ssnPattern(R"(^(?!6660009\d{2})\d{3}-(?!00)\d{2}-(?!0{4})\d{4}$)");
return std::regex_match(ssn, ssnPattern);
}

1. Exemplo de Uso:

int main() {
std::cout << std::boolalpha;
std::cout << isValidSSN("856-45-6789") << std::endl; // true
std::cout << isValidSSN("000-45-6789") << std::endl; // false
std::cout << isValidSSN("856-452-6789") << std::endl; // false
std::cout << isValidSSN("856-45-0000") << std::endl; // false
return 0;
}

Como funciona:

• O padrão rejeita SSNs começando com 666, 000 ou qualquer série 9XX.

• Bloqueia números de grupo como "00" e números de série como "0000", ambos inválidos.

• Esta configuração permite capturar SSNs digitados incorretamente ou claramente inválidos antes que atinjam os fluxos de trabalho sensíveis da sua aplicação.

Experimente adaptar o regex para suas regras de negócio, ou estenda-o para validação em lote em conjuntos de dados maiores.

O que o Modificador i Faz no Regex de SSN?

Ao criar expressões regulares para validar Social Security Numbers, você pode encontrar o modificador i no final de um padrão regex, por exemplo, /^[\dX]{3}-?[\dX]{2}-?[\dX]{4}$/i. Mas o que isso realmente significa para sua validação de SSN?

A flag i torna seu padrão case-insensitive. No contexto de SSNs, você pode querer permitir casos especiais onde um "X" pode aparecer (como em SSNs mascarados ou de placeholder). Com o modificador i, seu regex corresponderia tanto a "X" maiúsculo quanto a "x" minúsculo em qualquer parte do SSN:

• Sem i: Corresponde apenas a "X" maiúsculo (ex.: 123-45-67X9)

• Com i: Corresponde tanto a "X" quanto a "x" (ex.: 123-45-67x9 ou 123-xx-xxxx)

Use o modificador i se você espera ou deseja aceitar qualquer um dos casos, especialmente ao lidar com dados de fontes diferentes onde o caso das letras pode variar. Isso garante que sua validação permaneça flexível sem perder valores legítimos.

Uma nota sobre precisão:

Validar Social Security Numbers (SSNs) com regex é um pouco mais matizado do que parece à primeira vista. Por exemplo, um padrão regex ligeiramente mais preciso seria:

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

Este padrão melhora o básico garantindo que:

• O primeiro grupo não seja "000", "666" ou qualquer número começando com "9"

• O segundo grupo não seja "00"

• O último grupo não seja "0000"

Ainda assim, mesmo um regex mais robusto como esse apenas elimina formatos obviamente inválidos, não pode garantir que o número foi oficialmente atribuído a alguém.

Flexibilidade de formato:
Dependendo das suas necessidades, você pode querer aceitar placeholders ou hifens opcionais, assim:

/^(\d{3}-?\d{2}-?\d{4})(xxx-xx-xxxx)$/i

Isso permite "xxx-xx-xxxx" ou variações sem hifens, o que pode ser útil em certos cenários de teste ou demonstração.

Conclusão:
Regex é ótimo para filtrar o impossível, não para confirmar o real. Sempre consulte documentação oficial ou serviços de validação se precisar verificar SSNs reais.

Dicas Pro

• Use .test() para verificações rápidas em validação de formulários ao vivo.

• Evite armazenar SSNs como texto simples. Use o Codificador Base64 para ofuscar valores antes da transmissão.

• Para maior segurança, combine validação regex com verificações no lado do servidor e criptografia.

• Teste regularmente seu regex com dados simulados usando nosso Gerador de String Aleatória ou Gerador de Token.

• Use o Conversor CSV para JSON se você estiver validando SSNs em lote a partir de arquivos enviados por usuários.

Combine com Estas Ferramentas

• JavaScript Regex Tester - Teste qualquer padrão regex ao vivo.

• Codificador Base64 - Codifique strings sensíveis antes de enviá-las pela web.

• Gerador de Token - Gere tokens seguros com suas regras regex.

• Conversor CSV para JSON - Gerencie grandes importações de SSNs para validação e armazenamento.