Que es SSN Regex?

Un Numero de Seguro Social (SSN) en los EE. UU. sigue el formato estandar:

XXX-XX-XXXX

Donde:

• XXX: Numero de area (3 digitos)

• XX: Numero de grupo (2 digitos)

• XXXX: Numero de serie (4 digitos)

Este formato garantiza una identificacion estructurada para propositos fiscales y legales. El uso de regex ayuda a validar si una cadena de entrada sigue estrictamente este formato.

Para considerarse un SSN valido, una cadena tambien debe cumplir estos criterios especificos:

• 9 digitos en total, separados en tres partes por guiones.

• Primera parte (Numero de area): 3 digitos; no puede ser 000, 666 ni ningun valor entre 900 y 999.

• Segunda parte (Numero de grupo): 2 digitos; debe estar entre 01 y 99 (no 00).

• Tercera parte (Numero de serie): 4 digitos; debe estar entre 0001 y 9999 (no 0000).

Estas reglas garantizan que solo los SSN correctamente estructurados y potencialmente validos superen la validacion, reduciendo errores y mejorando la integridad de los datos.

Patron Regex para SSN

El patron regex tipico para validar un SSN correctamente formateado es:

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

Desglose:

• ^\d{3} - Tres digitos al inicio

• - - Primer separador de guion

• \d{2} - Dos digitos

• - - Segundo guion

• \d{4}$ - Cuatro digitos al final

Esto garantiza una coincidencia estricta de formato como 123-45-6789.

Patrones Ampliados y Consideraciones

Mientras el patron anterior cubre el formato estandar de SSN, existen algunos escenarios adicionales y verificaciones mas estrictas que puede considerar:

• Exclusiones estrictas de valores invalidos: Para evitar SSN obviamente invalidos, puede usar un regex mas restrictivo que excluya ciertos valores:

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

• SSN enmascarados o de marcador de posicion: A veces se utilizan marcadores como XXX-XX-XXXX en documentacion o formularios:

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

• Formato flexible: Si desea permitir guiones opcionales o soportar marcadores en mayusculas o minusculas:

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

Elija el patron que mejor se adapte a su caso de uso.

Que hace valido un SSN?

• Nueve digitos en total: El SSN debe contener exactamente nueve digitos, separados por guiones.

• Tres partes separadas por guiones: El formato siempre es AAA-GG-SSSS.

• Restricciones del numero de area: Los primeros tres digitos no deben ser 000, 666 ni ningun numero del 900 al 999.

• Restricciones del numero de grupo: Los dos digitos del medio deben estar entre 01 y 99; el 00 no es valido.

• Restricciones del numero de serie: Los ultimos cuatro digitos deben estar entre 0001 y 9999; el 0000 no es valido.

Ejemplo de Codigo Python

import re
def is_valid_ssn(ssn):
pattern = re.compile(r'^\d{3}-\d{2}-\d{4}$')
return bool(pattern.fullmatch(ssn))
Test Cases
print(is_valid_ssn("123-45-6789"))  # True
print(is_valid_ssn("123456789"))    # False
print(is_valid_ssn("12-345-6789"))  # False

Pruebe variaciones de regex con el Probador de Regex Python.

Complejidad Temporal y Espacial

• Complejidad Temporal: Verificar una cadena contra el regex de SSN se ejecuta en tiempo O(N), donde N es la longitud de la cadena del SSN.

• Complejidad Espacial: La validacion mediante regex usa O(1) de espacio auxiliar, ya que no requiere almacenar datos adicionales proporcionales al tamano de la entrada.

Casos de Uso

• Verificacion de identidad de usuario: Garantice una entrada correcta de SSN durante el registro o la incorporacion de usuarios.

• Limpieza de datos: Detecte y corrija SSN con formato incorrecto en bases de datos.

• Seguridad y cumplimiento: Verifique el formato del SSN antes de transmitir datos sensibles.

Puede combinarlo con:

• Validador Email Regex Python para verificacion de cuentas

• Validador IP Address Regex Python para seguridad del sistema

• Validador URL Regex Python para proteger campos de formulario

Metacaracteres Regex Utilizados

• ^: Ancla el inicio de la cadena

• \d: Coincide con cualquier digito (0-9)

• {n}: Coincide exactamente con n digitos

• -: Coincide con guiones literales en SSN

• $: Ancla el final de la cadena

Como Validar SSN en JavaScript

// Regular expression for strict SSN validation
const ssnPattern = /^(?!6660009\d{2})\d{3}-(?!00)\d{2}-(?!0{4})\d{4}$/;
function isValidSSN(ssn) {
if (!ssn) return false; // Reject empty inputs
return ssnPattern.test(ssn);
}
// Example usage:
console.log(isValidSSN("856-45-6789")); // true (valid)
console.log(isValidSSN("000-45-6789")); // false (invalid area)
console.log(isValidSSN("856-452-6789")); // false (incorrect format)
console.log(isValidSSN("856-45-0000")); // false (invalid serial)

Que hace el Regex

• Garantiza que el numero de area (primeros tres digitos) no sea 666, 000 ni este en el rango 900-999.

• Confirma que el numero de grupo (dos digitos del medio) no sea 00.

• Verifica que el numero de serie (ultimos cuatro digitos) no sean todos ceros.

• Exige la colocacion correcta de guiones.

Ejemplo en Java para Validacion de SSN

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class SSNValidator {
private static final String SSN_REGEX =
"^(?!6660009\d{2})\d{3}-(?!00)\d{2}-(?!0{4})\d{4}$";
private static final Pattern pattern = Pattern.compile(SSN_REGEX);
public static boolean isValidSSN(String ssn) {
    if (ssn == null) return false;
    Matcher matcher = pattern.matcher(ssn);
    return matcher.matches();
}

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
}

}

Ejemplo en C# para Validacion de SSN

using System;
using System.Text.RegularExpressions;
public class SSNValidator
{
public static bool IsValidSSN(string ssn)
{
string pattern = @"^(?!6660009\d{2})\d{3}-(?!00)\d{2}-(?!0000)\d{4}$";
return Regex.IsMatch(ssn, pattern);
}
public static void Main()
{
    var testSSNs = new[]
    {
        "856-45-6789",
        "000-45-6789",
        "856-452-6789",
        "856-45-0000"
    };

    foreach (var ssn in testSSNs)
    {
        Console.WriteLine($"{ssn}: {IsValidSSN(ssn)}");
    }
}

}

Consejos Profesionales

• Siempre ancle los patrones con ^ y $ para evitar coincidencias parciales.

• Preprocese la entrada del usuario para eliminar espacios en blanco antes de la validacion.

• Puede ampliar la validacion para excluir combinaciones invalidas (como 000 o 666) usando regex avanzado o logica adicional.

• Evite almacenar SSN en texto plano: cifralos despues de la validacion.

• Use el Probador de Regex Python para experimentar antes de desplegar.

• Combine con el Validador Date Regex Python si los SSN forman parte de un documento estructurado mas amplio.