Qu'est-ce qu'un SSN Regex ?

Un numéro de sécurité sociale (SSN) aux États-Unis suit le format standard :

XXX-XX-XXXX

où :

• XXX : numéro de zone (3 chiffres)

• XX : numéro de groupe (2 chiffres)

• XXXX : numéro de série (4 chiffres)

Ce format garantit une identification structurée à des fins fiscales et juridiques. L'utilisation de regex permet de vérifier qu'une chaîne respecte strictement ce format.

Pour être considéré valide, un SSN doit également satisfaire les critères suivants :

• 9 chiffres au total, répartis en trois parties séparées par des tirets.

• Première partie (numéro de zone) : 3 chiffres ; ne peut pas être 000, 666, ni toute valeur entre 900 et 999.

• Deuxième partie (numéro de groupe) : 2 chiffres ; doit être compris entre 01 et 99 (pas 00).

• Troisième partie (numéro de série) : 4 chiffres ; doit être compris entre 0001 et 9999 (pas 0000).

Ces règles garantissent que seuls les SSN correctement structurés et potentiellement valides passent la validation, réduisant les erreurs et améliorant l'intégrité des données.

Pattern Regex pour SSN

Le pattern regex classique pour valider un SSN correctement formaté est :

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

Décomposition :

• ^\d{3} : trois chiffres au début

• - : premier séparateur trait d'union

• \d{2} : deux chiffres

• - : second trait d'union

• \d{4}$ : quatre chiffres en fin de chaîne

Cela garantit une correspondance stricte comme 123-45-6789.

Patterns étendus et considérations

Le pattern ci-dessus couvre le format SSN standard, mais quelques scénarios supplémentaires méritent attention :

• Exclusions de valeurs invalides : Pour éviter les SSN manifestement invalides, vous pouvez utiliser un regex plus restrictif avec des lookaheads négatifs :
  ^(?!(0006669))\d{3}-(?!00)\d{2}-(?!0000)\d{4}$

• SSN masqués ou fictifs : Pour accepter également le format masqué XXX-XX-XXXX, combinez les deux alternatives avec le pipe.

• Format flexible : Pour autoriser des tirets optionnels ou des espaces réservés en majuscules/minuscules, utilisez :
  ^(\d{3}-?\d{2}-?\d{4}[Xx]{3}-?[Xx]{2}-?[Xx]{4})$

Choisissez le pattern qui correspond le mieux à votre cas d'usage.

Qu'est-ce qui rend un SSN valide ?

• Neuf chiffres au total : le SSN doit contenir exactement neuf chiffres, séparés par des tirets.

• Trois parties séparées par des tirets : le format est toujours XXX-XX-XXXX.

• Restrictions sur le numéro de zone : les trois premiers chiffres ne doivent pas être 000, 666, ni un nombre compris entre 900 et 999.

• Restrictions sur le numéro de groupe : les deux chiffres du milieu doivent être compris entre 01 et 99 ; 00 est invalide.

• Restrictions sur le numéro de série : les quatre derniers chiffres doivent être compris entre 0001 et 9999 ; 0000 est invalide.

Exemple de code 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

Testez des variations de regex avec le Testeur Regex Python.

Complexité temporelle et spatiale

• Complexité temporelle : O(N) où N est la longueur de la chaîne SSN, le moteur regex parcourant chaque caractère une fois.

• Complexité spatiale : O(1) en mémoire auxiliaire, aucune donnée supplémentaire proportionnelle à l'entrée n'est stockée.

Cas d'utilisation

• Vérification d'identité : garantissez la saisie correcte d'un SSN lors de l'inscription ou de l'intégration d'un utilisateur.

• Nettoyage de données : détectez et corrigez les SSN mal formatés dans les bases de données.

• Sécurité et conformité : vérifiez le format SSN avant de transmettre des données sensibles.

Combinez cet outil avec :

• Validateur Email Regex Python pour la vérification de compte

• Validateur IP Regex Python pour la sécurité système

• Validateur URL Regex Python pour sécuriser les champs de formulaire

Métacaractères regex utilisés

• ^ : ancre le début de la chaîne

• \d : correspond à tout chiffre (0-9)

• {n} : correspond exactement à n chiffres

• - : correspond aux tirets littéraux des SSN

• $ : ancre la fin de la chaîne

Validation de 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)

Ce que fait le regex

• S'assure que le numéro de zone (trois premiers chiffres) n'est pas 666, 000 ni compris dans la plage 900-999.

• Vérifie que le numéro de groupe (deux chiffres du milieu) n'est pas 00.

• Vérifie que le numéro de série (quatre derniers chiffres) n'est pas composé uniquement de zéros.

• Impose le placement correct des tirets.

Exemple Java pour la validation 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
}

}

Bonnes pratiques

• Ancrez toujours les patterns avec ^ et $ pour éviter les correspondances partielles.

• Supprimez les espaces de début/fin avant la validation.

• Pour une validation plus robuste, excluez les combinaisons invalides avec des lookaheads négatifs.

• Ne stockez jamais de SSN en clair : chiffrez-les après validation.

• Utilisez le Testeur Regex Python pour expérimenter avant de déployer.

• Combinez avec le Validateur Date Regex Python si les SSN font partie d'un document structuré plus large.