Valider les numéros de téléphone avec Java Regex

1. Vue d'ensemble

Parfois, nous devons valider le texte pour nous assurer que son contenu est conforme à un format. Dans ce tutoriel rapide, nous verrons comment valider différents formats de numéros de téléphone à l'aide d'expressions régulières.

2. Expressions régulières pour valider les numéros de téléphone

2.1. Numéro à dix chiffres

Commençons par une expression simple qui vérifiera si le nombre a dix chiffres et rien d'autre :

@Test public void whenMatchesTenDigitsNumber_thenCorrect() { Pattern pattern = Pattern.compile("^\\d{10}$"); Matcher matcher = pattern.matcher("2055550125"); assertTrue(matcher.matches()); }

Cette expression autorisera des nombres comme 2055550125 .

2.2. Nombre avec des espaces, des points ou des traits d'union

Dans le deuxième exemple, voyons comment nous pouvons autoriser des espaces, des points ou des traits d'union facultatifs (-) entre les nombres:

@Test public void whenMatchesTenDigitsNumberWhitespacesDotHyphen_thenCorrect() { Pattern pattern = Pattern.compile("^(\\d{3}[- .]?){2}\\d{4}$"); Matcher matcher = pattern.matcher("202 555 0125"); assertTrue(matcher.matches()); }

Pour atteindre cet objectif supplémentaire (espace ou trait d'union optionnel), nous avons simplement ajouté les caractères:

  • [-.]?

Ce modèle autorisera des nombres tels que 2055550125 , 202 555 0125 , 202.555.0125 et 202-555-0125 .

2.3. Nombre avec parenthèses

Ensuite, ajoutons la possibilité d'avoir la première partie de notre téléphone entre parenthèses :

@Test public void whenMatchesTenDigitsNumberParenthesis_thenCorrect() { Pattern pattern = Pattern.compile"^((\\(\\d{3}\\))|\\d{3})[- .]?\\d{3}[- .]?\\d{4}$"); Matcher matcher = pattern.matcher("(202) 555-0125"); assertTrue(matcher.matches()); }

Pour autoriser la parenthèse facultative dans le nombre, nous avons ajouté les caractères suivants à notre expression régulière:

  • (\\ (\\ d {3} \\)) | \\ d {3})

Cette expression autorisera des nombres comme (202) 5550125 , (202) 555-0125 ou (202) -555-0125 . De plus, cette expression autorisera également les numéros de téléphone couverts dans l'exemple précédent.

2.4. Numéro avec préfixe international

Enfin, voyons comment autoriser un préfixe international au début d'un numéro de téléphone :

@Test public void whenMatchesTenDigitsNumberPrefix_thenCorrect() { Pattern pattern = Pattern.compile("^(\\+\\d{1,3}( )?)?((\\(\\d{3}\\))|\\d{3})[- .]?\\d{3}[- .]?\\d{4}$"); Matcher matcher = pattern.matcher("+111 (202) 555-0125"); assertTrue(matcher.matches()); } 

Pour permettre le préfixe dans notre numéro, nous avons ajouté au début de notre motif les caractères:

  • (\\ + \\ d {1,3} ()?)?

Cette expression permettra aux numéros de téléphone d'inclure des préfixes internationaux, en tenant compte du fait que les préfixes internationaux sont normalement des nombres avec un maximum de trois chiffres.

3. Application de plusieurs expressions régulières

Comme nous l'avons vu, un numéro de téléphone valide peut prendre plusieurs formats différents. Par conséquent, nous pouvons vouloir vérifier si notre chaîne est conforme à l'un de ces formats.

Dans la dernière section, nous avons commencé avec une expression simple et ajouté plus de complexité pour atteindre l'objectif de couvrir plus d'un format. Cependant, il est parfois impossible d'utiliser une seule expression. Dans cette section, nous verrons comment joindre plusieurs expressions régulières en une seule .

Si nous ne parvenons pas à créer une expression régulière commune qui puisse valider tous les cas possibles que nous voulons couvrir, nous pouvons définir différentes expressions pour chacun des cas, puis les utiliser tous ensemble en les concaténant avec un symbole pipe (|).

Voyons un exemple où nous utilisons les expressions suivantes:

  • L'expression utilisée dans la dernière section:
    • ^ (\\ + \\ d {1,3} ()?)? ((\\ (\\ d {3} \\)) | \\ d {3}) [-.]? \\ d { 3} [-.]? \\ d {4} $
  • Expression régulière pour autoriser les nombres comme +111 123 456 789:
    • ^ (\\ + \\ d {1,3} ()?)? (\\ d {3} []?) {2} \\ d {3} $
  • Modèle pour autoriser des nombres comme +111123 45 67 89:
    • ^ (\\ + \\ d {1,3} ()?)? (\\ d {3} []?) (\\ d {2} []?) {2} \\ d {2} $
@Test public void whenMatchesPhoneNumber_thenCorrect() { 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}$"; 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"}; Pattern pattern = Pattern.compile(patterns); for(String phoneNumber : validPhoneNumbers) { Matcher matcher = pattern.matcher(phoneNumber); assertTrue(matcher.matches()); } }

Comme nous pouvons le voir dans l'exemple ci-dessus, en utilisant le symbole du tube, nous pouvons utiliser les trois expressions en une seule fois, ce qui nous permet de couvrir plus de cas qu'avec une seule expression régulière.

4. Conclusion

Dans cet article, nous avons vu comment vérifier si une chaîne contient un numéro de téléphone valide à l'aide de différentes expressions régulières. Nous avons également appris à utiliser plusieurs expressions régulières en même temps.

Comme toujours, le code source complet de l'article est disponible à l'adresse over sur GitHub.