RegEx : Lignes fixes du Royaume-Uni, numéros de téléphone mobile

Question

J'ai eu du mal à trouver une solution adéquate :-)

J'ai besoin d'une expression regex qui correspondra à tous les numéros de téléphone et téléphones mobiles du Royaume-Uni.

Jusqu'à présent, celui-ci semble couvrir la plupart des numéros du Royaume-Uni :

^0\d{2,4}[ -]{1}[\d]{3}[\d -]{1}[\d -]{1}[\d]{1,4}$

Cependant, les numéros de téléphone mobile ne fonctionnent pas avec cette expression regex, ni les numéros de téléphone écrits dans un seul bloc solide comme 01234567890.

Quelqu'un peut-il m'aider à créer l'expression regex requise ?

Answer 1

  [\d -]{1}

est manifestement incorrect : un chiffre OU un espace OU un trait d'union.

  01000 123456

01000 n'est pas un indicatif régional valide au Royaume-Uni. 123456 n'est pas un numéro local valide.

Il est important que les données d'essai soient des indicatifs régionaux réels et des tranches de numéros réelles.

  ^\s*(?(020[7,8]{1})?[ ]?[1-9]{1}[0-9{2}[ ]?[0-9]{4})|(0[1-8]{1}[0-9]{3})?[ ]?[1-9]{1}[0-9]{2}[ ]?[0-9]{3})\s*|[0-9]+[ ]?[0-9]+$

Le schéma ci-dessus est un déchet pour de nombreuses raisons différentes.

[7,8] correspond à 7 ou à une virgule ou à 8. Il n'est pas nécessaire de faire correspondre une virgule.

Les nombres londoniens commencent également par 3 et pas seulement par 7 ou 8.

Les numéros 020 de Londres ne sont pas les seuls numéros au format 2+8 ; voir aussi 023, 024, 028 et 029.

[1-9]{1} se simplifie en [1-9].

[ ] ? se simplifie en \s ?

Après avoir trouvé le 0 initial une fois, pourquoi continuer à le chercher encore et encore ?

^(0....|0....|0....|0....)$ se simplifie en ^0(....|....|....|....|....)$.

Sérieusement. ([1]|[2]|[3]|[7]){1} se simplifie en [1237] ici.

Les numéros de téléphone britanniques utilisent une variété de formats : 2+8, 3+7, 3+6, 4+6, 4+5, 5+5, 5+4. Certains utilisateurs ne savent pas quel format correspond à quelle plage de numéros et peuvent utiliser le mauvais format lors de la saisie. Laissez-les faire ; ce qui vous intéresse, ce sont les DIGITS.

Étape 1 : Vérifier que le format d'entrée semble valide

Veillez à ce que la saisie ressemble à un numéro de téléphone britannique. Acceptez divers préfixes de numérotation, +44, 011 44, 00 44 avec ou sans parenthèses, tirets ou espaces ; ou le format national avec un 0 en tête. Laissez l'utilisateur utiliser le format qu'il souhaite pour le reste du numéro : (020) 3555 7788 ou 00 (44) 203 555 7788 ou 02035-557-788 même si ce n'est pas le bon format pour ce numéro particulier. Ne vous inquiétez pas des parenthèses non équilibrées. La partie importante de la saisie est de s'assurer que le nombre de chiffres est correct. La ponctuation et les espaces n'ont pas d'importance.

  ^\(?(?:(?:0(?:0|11)\)?[\s-]?\(?|\+)44\)?[\s-]?\(?(?:0\)?[\s-]?\(?)?|0)(?:\d{5}\)?[\s-]?\d{4,5}|\d{4}\)?[\s-]?(?:\d{5}|\d{3}[\s-]?\d{3})|\d{3}\)?[\s-]?\d{3}[\s-]?\d{3,4}|\d{2}\)?[\s-]?\d{4}[\s-]?\d{4}|8(?:00[\s-]?11[\s-]?11|45[\s-]?46[\s-]?4\d))(?:(?:[\s-]?(?:x|ext\.?\s?|\#)\d+)?)$

Le modèle ci-dessus correspond à des parenthèses ouvrantes facultatives, suivies de 00 ou 011 et de parenthèses fermantes facultatives, suivies d'un espace ou d'un trait d'union facultatif, suivi de parenthèses ouvrantes facultatives. Ou bien, les parenthèses ouvrantes initiales sont suivies d'un + littéral sans espace ou trait d'union suivant. L'une ou l'autre des deux options précédentes est ensuite suivie de 44 avec des parenthèses fermantes facultatives, suivi d'un espace ou d'un trait d'union facultatif, suivi de 0 entre parenthèses facultatives, suivi d'un espace ou d'un trait d'union facultatif, suivi de parenthèses ouvrantes facultatives (format international). Sinon, le modèle correspond à des parenthèses ouvrantes initiales facultatives suivies du code tronc 0 (format national).

La partie précédente est ensuite suivie du NDC (indicatif régional) et du numéro de téléphone de l'abonné au format 2+8, 3+7, 3+6, 4+6, 4+5, 5+5 ou 5+4 avec ou sans espaces et/ou tirets. Il est également possible de prévoir des parenthèses fermantes facultatives et/ou un espace ou un trait d'union facultatif après l'endroit où l'utilisateur pense que l'indicatif régional se termine et où le numéro d'abonné local commence. Le modèle permet d'utiliser n'importe quel format avec n'importe quel numéro de GB. Le format d'affichage doit être corrigé par une logique ultérieure si l'utilisateur a utilisé un format incorrect pour ce numéro lors de la saisie.

Le motif se termine par un numéro d'extension facultatif sous la forme d'un espace ou d'un tiret facultatif suivi de x, ext et d'un point facultatif, ou #, suivi des chiffres du numéro d'extension. L'ensemble du modèle ne prend pas la peine de vérifier si les parenthèses sont équilibrées, car elles seront supprimées du numéro à l'étape suivante.

A ce stade, vous ne vous souciez pas de savoir si le numéro commence par 01 ou 07 ou autre chose. Vous ne vous souciez pas non plus de savoir s'il s'agit d'un indicatif régional valide. Les étapes suivantes traiteront de ces questions.

Étape 2 : Extraire la DSN afin de pouvoir vérifier plus en détail sa longueur et sa portée.

Après avoir vérifié que l'entrée ressemble à un numéro de téléphone GB à l'aide du modèle ci-dessus, l'étape suivante consiste à extraire la partie NNO afin d'en vérifier plus en détail la validité, puis de la formater de la manière appropriée pour la plage de numéros applicable.

  ^\(?(?:(?:0(?:0|11)\)?[\s-]?\(?|\+)(44)\)?[\s-]?\(?(?:0\)?[\s-]?\(?)?|0)([1-9]\d{1,4}\)?[\s\d-]+)(?:((?:x|ext\.?\s?|\#)\d+)?)$

Utilisez le modèle ci-dessus pour extraire le '44' de $1 afin de savoir si le format international a été utilisé, sinon supposez le format national si $1 est nul.

Extraire les détails du numéro d'extension facultatif de 3 $ et les stocker pour une utilisation ultérieure.

Extraire le NNO (y compris les espaces, les traits d'union et les parenthèses) de $2.

Étape 3 : Validation de la DSN

Supprimez les espaces, les traits d'union et les parenthèses de $2 et utilisez d'autres modèles RegEx pour vérifier la longueur et la plage et identifier le type de nombre.

Ces modèles seront beaucoup plus simples, puisqu'ils n'auront pas à composer avec divers préfixes de numérotation ou codes de pays.

Le modèle permettant de faire correspondre des numéros de téléphone mobile valides est donc aussi simple que

  ^7([45789]\d{2}|624)\d{6}$

Le taux de prime est de

  ^9[018]\d{8}$

Il y aura un certain nombre d'autres modèles pour chaque type de numéro : lignes fixes, tarifs professionnels, non géographiques, VoIP, etc.

En décomposant le problème en plusieurs étapes, il est possible d'autoriser un très large éventail de formats d'entrée et de vérifier de manière très détaillée la plage de numéros et la longueur de la DSN.

Étape 4 : Enregistrez le numéro

Une fois le NNO extrait et validé, enregistrez le numéro avec le code pays et tous les autres chiffres sans espace ni ponctuation, par exemple 442035557788.

Étape 5 : Formater le numéro pour l'affichage

Un autre ensemble de règles simples peut être utilisé pour formater le numéro avec le +44 ou le 0 requis ajouté au début.

La règle pour les numéros commençant par 03 est

  ^44(3\d{2})(\d{3])(\d{4})$

formaté comme suit

  0$1 $2 $3 or as +44 $1 $2 $3

et pour les numéros commençant par 02, c'est

  ^44(2\d)(\d{4})(\d{4})$ 

formaté comme suit

  (0$1) $2 $3 or as +44 $1 $2 $3

La liste complète est assez longue. Je pourrais la copier et la coller dans ce fil de discussion, mais il serait difficile de maintenir cette information à plusieurs endroits au fil du temps. Pour l'instant, la liste complète se trouve à l'adresse suivante : http://aa-asterisk.org.uk/index.php/Regular_Expressions_for_Validating_and_Formatting_GB_Telephone_Numbers

Answer 2

Étant donné que les gens écrivent parfois leurs nombres avec des espaces à des endroits aléatoires, il serait peut-être préférable d'ignorer tous les espaces - vous pourriez alors utiliser une regex aussi simple que celle-ci :

^0( \d ?){10}$

Cela correspond :

• 01234567890
• 01234 234567
• 0121 3423 456
• 01213 423456
• 01000 123456

Mais cela correspondrait aussi :

• 01 2 3 4 5 6 7 8 9 0

Vous n'aimez peut-être pas ça, mais c'est certainement plus simple.

Answer 3

Supprimez tous les espaces et les caractères non numériques, puis faites le test. Ce sera beaucoup plus facile que d'essayer de tenir compte de toutes les options possibles autour des parenthèses, des espaces, etc. Essayez ce qui suit :

@"^(([0]{1})|([\+][4]{2}))([1]|[2]|[3]|[7]){1}\d{8,9}$"

Commence par 0 o +44 (pour l'international) - je suis sûr que vous pourriez ajouter 0044 si vous le vouliez.
Il dispose ensuite d'un 1 , 2 , 3 o 7 .
Il comporte ensuite 8 ou 9 chiffres.

Si vous voulez être encore plus malin, ce qui suit peut être une référence utile : http://en.wikipedia.org/wiki/Telephone_numbers_in_the_United_Kingdom

Answer 4

Cette regex ferait-elle l'affaire ?

//  using System.Text.RegularExpressions;

/// <summary>
///  Regular expression built for C# on: Wed, Sep 8, 2010, 06:38:28 
///  Using Expresso Version: 3.0.2766, http://www.ultrapico.com
///  
///  A description of the regular expression:
///  
///  [1]: A numbered capture group. [\+44], zero or one repetitions
///      \+44
///          Literal +
///          44
///  [2]: A numbered capture group. [\s+], zero or one repetitions
///      Whitespace, one or more repetitions
///  [3]: A numbered capture group. [\(?]
///      Literal (, zero or one repetitions
///  [area_code]: A named capture group. [(\d{1,5}|\d{4}\s+?\d{1,2})]
///      [4]: A numbered capture group. [\d{1,5}|\d{4}\s+?\d{1,2}]
///          Select from 2 alternatives
///              Any digit, between 1 and 5 repetitions
///              \d{4}\s+?\d{1,2}
///                  Any digit, exactly 4 repetitions
///                  Whitespace, one or more repetitions, as few as possible
///                  Any digit, between 1 and 2 repetitions
///  [5]: A numbered capture group. [\)?]
///      Literal ), zero or one repetitions
///  [6]: A numbered capture group. [\s+|-], zero or one repetitions
///      Select from 2 alternatives
///          Whitespace, one or more repetitions
///          -
///  [tel_no]: A named capture group. [(\d{1,4}(\s+|-)?\d{1,4}|(\d{6}))]
///      [7]: A numbered capture group. [\d{1,4}(\s+|-)?\d{1,4}|(\d{6})]
///          Select from 2 alternatives
///              \d{1,4}(\s+|-)?\d{1,4}
///                  Any digit, between 1 and 4 repetitions
///                  [8]: A numbered capture group. [\s+|-], zero or one repetitions
///                      Select from 2 alternatives
///                          Whitespace, one or more repetitions
///                          -
///                  Any digit, between 1 and 4 repetitions
///              [9]: A numbered capture group. [\d{6}]
///                  Any digit, exactly 6 repetitions
///  
///
/// </summary>
public Regex MyRegex = new Regex(
      "(\\+44)?\r\n(\\s+)?\r\n(\\(?)\r\n(?<area_code>(\\d{1,5}|\\d{4}\\s+"+
      "?\\d{1,2}))(\\)?)\r\n(\\s+|-)?\r\n(?<tel_no>\r\n(\\d{1,4}\r\n(\\s+|-"+
      ")?\\d{1,4}\r\n|(\\d{6})\r\n))",
    RegexOptions.IgnoreCase
    | RegexOptions.Singleline
    | RegexOptions.ExplicitCapture
    | RegexOptions.CultureInvariant
    | RegexOptions.IgnorePatternWhitespace
    | RegexOptions.Compiled
    );

//// Replace the matched text in the InputText using the replacement pattern
// string result = MyRegex.Replace(InputText,MyRegexReplace);

//// Split the InputText wherever the regex matches
// string[] results = MyRegex.Split(InputText);

//// Capture the first Match, if any, in the InputText
// Match m = MyRegex.Match(InputText);

//// Capture all Matches in the InputText
// MatchCollection ms = MyRegex.Matches(InputText);

//// Test to see if there is a match in the InputText
// bool IsMatch = MyRegex.IsMatch(InputText);

//// Get the names of all the named and numbered capture groups
// string[] GroupNames = MyRegex.GetGroupNames();

//// Get the numbers of all the named and numbered capture groups
// int[] GroupNumbers = MyRegex.GetGroupNumbers();

Remarquez comment les espaces et les tirets sont facultatifs et peuvent en faire partie De plus, il est maintenant divisé en deux groupes de capture appelés area_code y tel_no pour le décomposer et l'extraire plus facilement.

Answer 5

Il ne s'agit pas d'une seule regex, mais il y a un exemple de code provenant de Braemoor Software qui est simple à suivre et assez complet.

La version JS est probablement la plus facile à lire. Elle supprime les espaces et les traits d'union (je sais que vous avez dit que vous ne pouviez pas le faire), puis applique un certain nombre de contrôles positifs et négatifs sur les expressions rationnelles.