Validateur Regex Java de numéros de téléphone

Qu'est-ce qu'un regex de numéro de téléphone ?

Les numéros de téléphone peuvent apparaître sous de nombreux formats, en particulier lorsqu'on prend en charge plusieurs pays. Un regex (expression régulière) aide à vérifier que les patterns correspondent pour s'assurer que les utilisateurs saisissent des coordonnées valides.

En Java, les patterns regex pour les numéros de téléphone valident généralement :

• Les indicatifs de pays optionnels (ex. +91, +1)

• Les formats uniquement numériques (ex. 9876543210)

• Les formats lisibles avec tirets, espaces ou crochets (ex. (123) 456-7890)

Construire des patterns regex plus flexibles

La création de patterns regex pour la validation des numéros de téléphone est souvent plus simple lorsqu'on commence simplement, puis qu'on ajoute de la complexité progressivement :

1. Commencer par les bases :
Faites correspondre des numéros de 10 chiffres simples.

2. Ajouter de la flexibilité de formatage :
Autorisez les espaces, tirets ou points optionnels entre les groupes de chiffres.

3. Introduire les parenthèses :
Adaptez votre regex pour reconnaître optionnellement les parenthèses autour de l'indicatif de zone (ex. (123) 456-7890).

4. Prendre en compte les préfixes internationaux :
Ajoutez un signe plus (+) optionnel suivi de l'indicatif de pays (jusqu'à trois chiffres).

Cette approche progressive fait évoluer votre regex d'un validateur local strict vers un pattern robuste acceptant une large gamme de formats réels.

Fonctionnalités principales

• Validation des numéros locaux et internationaux

• Prise en charge des formats avec indicatifs de pays, tirets, espaces ou crochets

• Améliore la précision des données et prévient les soumissions invalides

• Aperçu du pattern regex Java et résultat du test

• Retour en temps réel pour la validation

Patterns regex courants

1. Numéro simple de 10 chiffres :

   
   Correspond à : 9876543210

   ^\d{10}$

2. Numéro international avec indicatif de pays optionnel :

   
   Correspond à : +919876543210, 19876543210

   ^\+?[1-9]{1}[0-9]{7,14}$

3. Numéro formaté de style américain :

   
   Correspond à : (123) 456-7890, 123-456-7890, 1234567890

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

Autoriser les espaces, points ou tirets

Pour accommoder les formats avec espaces, points ou tirets, utilisez un pattern autorisant ces séparateurs optionnels :

Pattern :

^\d{3}[-.\s]?\d{3}[-.\s]?\d{4}$

Correspond à :

• 2055550125

• 202 555 0125

• 202.555.0125

• 202-555-0125

Vérifier plusieurs formats en Java

Lorsqu'un seul pattern regex ne suffit pas, combinez plusieurs patterns à l'aide du symbole pipe (|). Le pipe agit comme un OU logique, permettant la validation si la saisie correspond à l'un des patterns listés :

String regex = "^(\\+\\d{1,3}( )?)?((\\(\\d{3}\\))\\d{3})[- .]?\\d{3}[- .]?\\d{4}$"
             + "^(\\+\\d{1,3}( )?)?(\\d{3}[ ]?){2}\\d{3}$"
             + "^(\\+\\d{1,3}( )?)?(\\d{3}[ ]?)(\\d{2}[ ]?){2}\\d{2}$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(phoneNumber);
boolean isValid = matcher.matches();

Combiner plusieurs patterns regex

// Combiner différents patterns avec l'opérateur pipe
String patterns = "^(\\+\\d{1,3}( )?)?((\\(\\d{3}\\))\\d{3})[- .]?\\d{3}[- .]?\\d{4}$"
                + "^(\\+\\d{1,3}( )?)?(\\d{3}[ ]?){2}\\d{3}$"
                + "^(\\+\\d{1,3}( )?)?(\\d{3}[ ]?)(\\d{2}[ ]?){2}\\d{2}$";
Pattern pattern = Pattern.compile(patterns);
String[] validPhoneNumbers = {
"2055550125",
"202 555 0125",
"(202) 555-0125",
"+111 (202) 555-0125",
"636 856 789",
"+111 636 856 789",
"636 85 67 89",
"+111 636 85 67 89"
};
for (String phoneNumber : validPhoneNumbers) {
Matcher matcher = pattern.matcher(phoneNumber);
System.out.println(phoneNumber + ": " + matcher.matches());
}

Comment ça fonctionne

1. Saisissez votre numéro de téléphone dans le champ de saisie.

2. Choisissez le pattern regex à tester.

3. L'outil vérifie si votre saisie correspond et affiche le résultat.

4. Utilisez le résultat pour valider des saisies en temps réel ou nettoyer des jeux de données.

Exemple de code (Java)

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class PhoneNumberValidator {
public static void main(String[] args) {
String phoneNumber = "+1-234-567-8901";
String regex = "^\+?[1-9]{1}[0-9]{7,14}$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(phoneNumber);

    if (matcher.matches()) {
        System.out.println("Phone number is valid.");
    } else {
        System.out.println("Phone number is invalid.");
    }
}

}

Valider plusieurs formats de numéros

Pour couvrir plusieurs formats, définissez des patterns séparés et combinez-les avec le pipe (|) :

Format américain : (123) 456-7890 ou 123-456-7890

String usPattern = ^(?\d{3})?[- ]?\d{3}[- ]?\d{4}$

International : +919876543210 ou 19876543210

String intlPattern = ^+?[1-9]{1}[0-9]{7,14}$

Combiner les patterns :

String combinedPattern = usPattern + "" + intlPattern; Pattern pattern = Pattern.compile(combinedPattern);

Conseils pro

• Utilisez ^ et $ pour ancrer le pattern au début et à la fin de la chaîne.

• Évitez les regex trop stricts pour les applications mondiales, les formats varient selon les pays.

• Utilisez des patterns regex différents pour la validation et le formatage (ex. affichage vs saisie).

• Combinez avec des bibliothèques de validation de formulaires pour une meilleure expérience utilisateur.

• Pour les imports de données, combinez cet outil avec le Convertisseur CSV vers JSON pour nettoyer les numéros en masse.

• Pour les API backend, utilisez cet outil avec le Validateur UUID Java pour valider les sessions.

Combiner avec ces outils

• Validateur Regex Email Java, valider les emails dans le même système.

• Validateur Regex UUID Java, confirmer les tokens d'identité lors de l'authentification.

• Validateur Regex Date Java, s'assurer que les formats de date dans les champs de formulaire sont valides.

• Encodeur Base64, encoder les informations sensibles comme les numéros de téléphone si nécessaire.