Une regex complète pour la validation du numéro de téléphone

https://stackoverflow.com/questions/123559

02-07-2019
|

Question

J'essaie de créer une regex complète pour valider les numéros de téléphone. Idéalement, les formats internationaux seraient pris en charge, mais les formats américains, notamment:

1-234-567-8901
1-234-567-8901 x1234
1-234-567-8901 ext1234
1 (234) 567-8901
1.234.567.8901
1/234/567/8901
12345678901

Je vais répondre à ma tentative actuelle, mais j'espère que quelqu'un aura quelque chose de mieux et / ou plus élégant.

La solution

Meilleure option ... il suffit de supprimer tous les caractères non numériques de la saisie (à l'exception des signes "x" et des "+"), en tenant compte de la tendance britannique à écrire des chiffres sous la forme non standard + 44 (0) ... lorsqu'il vous est demandé d'utiliser le préfixe international (dans ce cas spécifique, vous devez supprimer le (0) ).

Ensuite, vous vous retrouvez avec des valeurs telles que:

 12345678901
 12345678901x1234
 345678901x1234
 12344678901
 12345678901
 12345678901
 12345678901
 +4112345678
 +441234567890

Ensuite, lorsque vous affichez, reformatez à votre guise le contenu. par exemple

  1 (234) 567-8901
  1 (234) 567-8901 x1234

Autres conseils

Il s’avère qu’il existe une sorte de spécification pour cela, du moins pour l’Amérique du Nord, appelée NANP .

Vous devez spécifier exactement ce que vous voulez. Que sont les délimiteurs légaux? Des espaces, des tirets et des points? Aucun délimiteur autorisé? Peut-on mélanger des délimiteurs (par exemple, +0,111-222,3333)? Comment les extensions (par exemple, 111-222-3333 x 44444) vont-elles être traitées? Qu'en est-il des numéros spéciaux, comme le 911? L'indicatif régional sera-t-il facultatif ou obligatoire?

Voici un regex pour un nombre de 7 ou 10 chiffres, avec extensions autorisées, les délimiteurs sont des espaces, des tirets ou des points:

^(?:(?:\+?1\s*(?:[.-]\s*)?)?(?:\(\s*([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9])\s*\)|([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9]))\s*(?:[.-]\s*)?)?([2-9]1[02-9]|[2-9][02-9]1|[2-9][02-9]{2})\s*(?:[.-]\s*)?([0-9]{4})(?:\s*(?:#|x\.?|ext\.?|extension)\s*(\d+))?$

.*

Si l'utilisateur veut vous donner son numéro de téléphone, faites-lui confiance pour bien faire les choses. S'il ne veut pas vous le donner, le forcer à entrer un nombre valide l'enverra sur le site d'un concurrent ou lui fera saisir une chaîne aléatoire qui correspond à votre expression rationnelle. Je pourrais même être tenté de rechercher le numéro d’une ligne de sexe au tarif majoré et de le saisir à la place.

Je considérerais également l'un des éléments suivants comme des entrées valides sur un site Web:

"123 456 7890 until 6pm, then 098 765 4321"  
"123 456 7890 or try my mobile on 098 765 4321"  
"ex-directory - mind your own business"

Je suggérerais également de consulter le " libphonenumber " Google Library. Je sais que ce n'est pas regex mais il fait exactement ce que tu veux.

Par exemple, il reconnaîtra que:

15555555555

est un nombre possible mais non valide. Il prend également en charge des pays en dehors des États-Unis.

Principales fonctionnalités:

Analyser / formater / valider des numéros de téléphone pour tous les pays / régions du monde.
getNumberType - récupère le type du nombre en fonction du nombre lui-même; capable de distinguer les lignes fixes, mobiles, sans frais, à taux majoré, à coûts partagés, VoIP et numéros personnels (lorsque cela est possible).
isNumberMatch - Obtient un niveau de confiance permettant de déterminer si deux nombres peuvent être identiques.
getExampleNumber / getExampleNumberByType - fournit des exemples de numéros valides pour tous les pays / régions, avec la possibilité de spécifier le type d'exemple de numéro de téléphone requis.
isPossibleNumber - Déterminez rapidement si un numéro est un numéro de téléphone possible en utilisant uniquement les informations de longueur, bien plus rapidement qu'une validation complète.
isValidNumber - validation complète d'un numéro de téléphone pour une région à l'aide d'informations de longueur et de préfixe.
AsYouTypeFormatter - formate les numéros de téléphone à la volée lorsque les utilisateurs saisissent chaque chiffre.
findNumbers : recherche les nombres en saisie de texte.
PhoneNumberOfflineGeocoder - fournit des informations géographiques relatives à un numéro de téléphone.

Exemples

Le plus gros problème de la validation du numéro de téléphone est qu’il dépend fortement de la culture.

Amérique
- (408) 974 & # 8211; 2042 est un numéro américain valide
- (999) 974 & # 8211; 2042 n'est pas un numéro américain valide
Australie
- 0404 999 999 est un numéro valide australien
- (02) 9999 9999 est également un numéro australien valide
- (09) 9999 9999 n'est pas un numéro australien valide

Une expression régulière convient bien pour vérifier le format d'un numéro de téléphone, mais elle ne pourra pas vraiment vérifier la validité d'un numéro de téléphone.

Je suggérerais de ne pas utiliser une expression régulière simple pour tester votre numéro de téléphone et d'utiliser une bibliothèque telle que le libphonenumber (lien vers le projet GitHub) .

Présentation de libphonenumber!

En utilisant l'un de vos exemples les plus complexes, 1-234-567-8901 x1234 , vous obtenez les données suivantes dans libphonenumber (lien vers la démonstration en ligne) :

Validation Results

Result from isPossibleNumber()  true
Result from isValidNumber()     true

Formatting Results:

E164 format                    +12345678901
Original format                (234) 567-8901 ext. 123
National format                (234) 567-8901 ext. 123
International format           +1 234-567-8901 ext. 123
Out-of-country format from US  1 (234) 567-8901 ext. 123
Out-of-country format from CH  00 1 234-567-8901 ext. 123

Ainsi, non seulement vous apprenez si le numéro de téléphone est valide (quel qu'il soit), mais vous obtenez également un formatage de numéro de téléphone cohérent dans vos paramètres régionaux.

En prime, libphonenumber dispose également d'un certain nombre de jeux de données permettant de vérifier la validité des numéros de téléphone. Par conséquent, vérifiez un numéro tel que +61299999999 (la version internationale de (02) 9999 9999 . >) renvoie un nombre valide avec le formatage:

Validation Results

Result from isPossibleNumber()  true
Result from isValidNumber()     true

Formatting Results

E164 format                    +61299999999
Original format                61 2 9999 9999
National format                (02) 9999 9999
International format           +61 2 9999 9999
Out-of-country format from US  011 61 2 9999 9999
Out-of-country format from CH  00 61 2 9999 9999

libphonenumber vous offre également de nombreux avantages supplémentaires, tels que la capture de l'emplacement où le numéro de téléphone est détecté et l'obtention des informations de fuseau horaire à partir du numéro de téléphone:

PhoneNumberOfflineGeocoder Results
Location        Australia

PhoneNumberToTimeZonesMapper Results
Time zone(s)    [Australia/Sydney]

Mais le numéro de téléphone australien non valide ( (09) 9999 9999 ) indique qu'il ne s'agit pas d'un numéro de téléphone valide.

Validation Results

Result from isPossibleNumber()  true
Result from isValidNumber()     false

La version de Google contient du code pour Java et Javascript, mais des personnes ont également implémenté des bibliothèques pour d'autres langues utilisant le jeu de données de numéro de téléphone Google i18n:

PHP : https://github.com/giggsey/libphonenumber -pour-php
Python : https://github.com/daviddrysdale/python-phonenumbers
Ruby : https://github.com/sstephenson/global_phone
C # : https://github.com/twcclegg/libphonenumber-csharp
Objective-C : https://github.com/iziz/libPhoneNumber -iOS
JavaScript : https://github.com/ruimarinho/google-libphonenumber
Elixir : https://github.com/socialpaymentsbv/ex_phone_number

À moins que vous ne soyez certain que vous accepterez toujours les numéros d'une seule langue et qu'ils seront toujours dans un seul format, je suggérerais fortement de ne pas écrire votre propre code pour cela et d'utiliser libphonenumber pour valider et afficher numéros de téléphone.

/ ^ (?: (?: \ (? (?: 00 | \ +) ([1-4] \ d \ d | [1-9] \ d?) \)?)? [\ - \. \ \\\\ / /?? ((?: \ (? \ d {1,} \)? [\ - \. \ \\\ \\\ /]?) {0,}) (? : [\ - \. \ \\\\ /]? (?: # | ext \.? | extension | x) [\ - \. \ \\\ / /? (\ d +))? $ / i

Ceci correspond à:

 - (+351) 282 43 50 50
 - 90191919908
 - 555-8909
 - 001 6867684
 - 001 6867684x1
 - 1 (234) 567-8901
 - 1-234-567-8901 x1234
 - 1-234-567-8901 ext1234
 - 1-234 567.89/01 ext.1234
 - 1(234)5678901x1234
 - (123)8575973
 - (0055)(123)8575973

Sur $ n, il enregistre:

indicateur de pays
numéro de téléphone
extension

Vous pouvez le tester sur https://www.regexpal.com/?fam=99127

Bien que supprimer tous les espaces blancs soit une bonne chose, cela ne résout pas vraiment le problème posé, qui est de trouver une expression régulière. Prenons, par exemple, mon script de test qui télécharge une page Web et extrait tous les numéros de téléphone à l'aide de la regex. Puisque de toute façon vous avez besoin d’une expression rationnelle, vous pouvez également demander à l’expression rationnelle de faire tout le travail. Je suis venu avec ceci:

1?\W*([2-9][0-8][0-9])\W*([2-9][0-9]{2})\W*([0-9]{4})(\se?x?t?(\d*))?

Voici un script Perl pour le tester. Lorsque vous faites correspondre, $ 1 contient l'indicatif régional, $ 2 et $ 3 contiennent le numéro de téléphone et $ 5, l'extension. Mon script de test télécharge un fichier sur Internet et imprime tous les numéros de téléphone qu'il contient.

#!/usr/bin/perl

my $us_phone_regex =
        '1?\W*([2-9][0-8][0-9])\W*([2-9][0-9]{2})\W*([0-9]{4})(\se?x?t?(\d*))?';


my @tests =
(
"1-234-567-8901",
"1-234-567-8901 x1234",
"1-234-567-8901 ext1234",
"1 (234) 567-8901",
"1.234.567.8901",
"1/234/567/8901",
"12345678901",
"not a phone number"
);

foreach my $num (@tests)
{
        if( $num =~ m/$us_phone_regex/ )
        {
                print "match [$1-$2-$3]\n" if not defined $4;
                print "match [$1-$2-$3 $5]\n" if defined $4;
        }
        else
        {
                print "no match [$num]\n";
        }
}

#
# Extract all phone numbers from an arbitrary file.
#
my $external_filename =
        'http://web.textfiles.com/ezines/PHREAKSANDGEEKS/PnG-spring05.txt';
my @external_file = `curl $external_filename`;
foreach my $line (@external_file)
{
        if( $line =~ m/$us_phone_regex/ )
        {
                print "match $1 $2 $3\n";
        }
}

Modifier:

Vous pouvez changer \ W * en \ s * \ W? \ s * dans la regex pour le resserrer un peu. Je ne pensais pas à l'expression régulière en termes de validation de l'entrée d'un utilisateur sur un formulaire lorsque je l'ai écrit, mais cette modification rend possible l'utilisation de l'expression régulière à cette fin.

'1?\s*\W?\s*([2-9][0-8][0-9])\s*\W?\s*([2-9][0-9]{2})\s*\W?\s*([0-9]{4})(\se?x?t?(\d*))?';

J'ai répondu à cette question sur une autre question SO avant de décider d'inclure également ma réponse comme réponse à ce fil, car personne ne demandait comment exiger / ne pas exiger des éléments, il suffisait de distribuer des regex:

À partir de mon post sur ce site, j'ai créé un guide rapide pour aider toute personne à créer sa propre regex pour le format de numéro de téléphone souhaité, ce que je vais mettre en garde (comme je l'ai fait sur l'autre site): trop restrictif, vous risquez de ne pas obtenir les résultats escomptés, et il n’existe pas de solution unique. solution pour accepter tous les numéros de téléphone possibles dans le monde - seulement ce que vous décidez d’accepter comme format de votre choix. Utilisez-le à vos risques et périls.

Aide-mémoire rapide

Commencez l'expression: / ^
Si vous souhaitez demander un espace, utilisez: [\ s] ou \ s
Si vous souhaitez exiger une parenthèse, utilisez: [(] et [)] . Utiliser \ ( et \) est moche et peut rendre les choses confuses.
Si vous souhaitez que quelque chose soit facultatif, insérez un ? après
Si vous voulez un trait d'union, tapez simplement - ou [-] . Si vous ne le mettez pas d'abord ou dernier dans une série d'autres caractères, vous devrez peut-être l'échapper: \ -
Si vous souhaitez accepter différents choix dans un emplacement, mettez des options entre crochets: [-. \ s] nécessitera un trait d'union, un point ou un espace. Un point d'interrogation après le dernier crochet rendra toutes ces options facultatives pour cet emplacement.
\ d {3} : Requiert un nombre à 3 chiffres: 000-999. Sténographie pour [0-9] [0-9] [0-9] .
[2-9] : Requiert un chiffre 2-9 pour cet emplacement.
(\ + | 1 \ s)? : acceptez un " plus " ou un 1 et un espace (caractère de canal, | , est "ou") et rendez-le facultatif. Le " plus " le signe doit être échappé.
Si vous souhaitez que des numéros spécifiques correspondent à un emplacement, entrez-les: [246] nécessitera un 2, 4 ou 6. [77 | 78] nécessitera 77 ou 78.
$ / : mettez fin à l'expression

J'ai écrit le plus simple (même si je n'avais pas besoin de dot).

^([0-9\(\)\/\+ \-]*)$

Comme mentionné ci-dessous, il vérifie uniquement les caractères, pas sa structure / son ordre

Notez que la suppression des caractères () ne fonctionne pas pour un style d'écriture de nombres britanniques commun: +44 (0) 1234 567890 , ce qui signifie que vous composez le numéro international numéro:
+441234567890
ou au Royaume-Uni, composez le 01234567890

Si vous voulez juste vérifier que vous n’avez pas d’ordures aléatoires dans le champ (c’est-à-dire des spammeurs de formulaires), cette expression rationnelle devrait faire l'affaire:

^[0-9+\(\)#\.\s\/ext-]+$

Notez qu’il n’a pas de règles spéciales pour le nombre ou la validité des chiffres, il vérifie simplement que seuls les chiffres, parenthèses, tirets, plus, espace, dièse, astérisque, point, virgule, ou les lettres e , x , t sont présentes.

Il devrait être compatible avec les numéros internationaux et les formats de localisation. Prévoyez-vous un besoin d'autoriser des supports carrés, bouclés ou inclinés pour certaines régions? (actuellement, ils ne sont pas inclus).

Si vous souhaitez conserver les règles par chiffre (comme dans les indicatifs régionaux et les préfixes américains (codes d’échange) doivent se situer dans la plage allant de 200 à 999), bonne chance à vous. Il n’est pas amusant de maintenir un ensemble de règles complexes qui pourraient devenir obsolètes à n’importe quel moment dans l’avenir de n’importe quel pays du monde.

Et même si vous supprimez tous / la plupart des caractères non numériques peuvent fonctionner correctement côté serveur (surtout si vous envisagez de transmettre ces valeurs à un numéroteur), vous pouvez ne pas vouloir masquer les entrées de l'utilisateur lors de la validation, en particulier si vous veulent qu'ils fassent des corrections dans un autre domaine.

Avez-vous consulté RegExLib ?

La saisie du numéro de téléphone américain a ramené toute une liste de possibilités.

Ma tentative de regex non restrictive:

/^[+#*\(\)\[\]]*([0-9][ ext+-pw#*\(\)\[\]]*){6,45}$/

Accepte:

+(01) 123 (456) 789 ext555
123456
*44 123-456-789 [321]
123456
123456789012345678901234567890123456789012345
*****++[](][((( 123456tteexxttppww

Rejects:

mob 07777 777777
1234 567 890 after 5pm
john smith
(empty)
1234567890123456789012345678901234567890123456
911

Il vous appartient de le désinfecter pour l’afficher. Après l'avoir validé, pourrait être un nombre cependant.

J'ai trouvé que cela fonctionnait assez bien:

^\(*\+*[1-9]{0,3}\)*-*[1-9]{0,3}[-. /]*\(*[2-9]\d{2}\)*[-. /]*\d{3}[-. /]*\d{4} *e*x*t*\.* *\d{0,4}$

Cela fonctionne pour ces formats de nombres:

1-234-567-8901
1-234-567-8901 x1234
1-234-567-8901 ext1234
1 (234) 567-8901
1.234.567.8901
1/234/567/8901
12345678901
1-234-567-8901 ext. 1234
(+351) 282 433 5050

Veillez à utiliser des indicateurs globaux ET à plusieurs lignes pour vous en assurer.

Lien: http://www.regexr.com/3bp4b

Si vous parlez de validation de formulaire, l'expression rationnelle destinée à valider le sens correct ainsi que les données correctes sera extrêmement complexe en raison de la diversité des normes de pays et de fournisseurs. Il sera également difficile de se tenir au courant.

J'interprète la question comme cherchant un modèle largement valide, qui peut ne pas être cohérent en interne - par exemple, avoir un ensemble valide de nombres, mais ne validant pas le fait que la ligne de jonction, l'échange, etc. préfixe de code de pays.

L’Amérique du Nord est simple, et pour l’international, je préfère utiliser un modèle «idiomatique» qui couvre la manière dont les gens spécifient et se souviennent de leurs chiffres:

^((((\(\d{3}\))|(\d{3}-))\d{3}-\d{4})|(\+?\d{2}((-| )\d{1,8}){1,5}))(( x| ext)\d{1,5}){0,1}$

Le modèle nord-américain garantit que, si une parenthèse est incluse, les deux le sont. Les comptes internationaux pour un «+» initial et un code de pays facultatifs. Après cela, vous êtes dans l'idiome. Les correspondances valides seraient:

(xxx) xxx-xxxx
(xxx) -xxx-xxxx
(xxx) xxx-xxxx x123
12 1234 123 1 x1111
12 12 12 12 12
12 1 1234 123456 x12345
+12 1234 1234
+12 12 12 1234
+12 1234 5678
+12 12345678

Cela peut être biaisé car mon expérience est limitée à l’Amérique du Nord, à l’Europe et à un petit bout d’Asie.

Mon instinct est renforcé par le nombre de réponses à ce sujet - qu'il existe un nombre pratiquement infini de solutions à ce problème, dont aucune ne sera élégante.

Honnêtement, je vous recommanderais de ne pas essayer de valider les numéros de téléphone. Même si vous pouviez écrire un gros validateur poilu qui autoriserait tous les formats légitimes, il autoriserait pratiquement tout ce qui pourrait ressembler à un numéro de téléphone.

À mon avis, la solution la plus élégante consiste à valider une longueur minimale, rien de plus.

Il s'agit d'un modèle d'expression régulière simple pour les numéros de téléphone portable philippins:

((\+[0-9]{2})|0)[.\- ]?9[0-9]{2}[.\- ]?[0-9]{3}[.\- ]?[0-9]{4}

((\+63)|0)[.\- ]?9[0-9]{2}[.\- ]?[0-9]{3}[.\- ]?[0-9]{4}

correspondra à ceux-ci:

+63.917.123.4567  
+63-917-123-4567  
+63 917 123 4567  
+639171234567  
09171234567

Le premier correspondra à TOUT code de pays à deux chiffres, tandis que le second correspondra exclusivement au code de pays des Philippines.

Testez-le ici: http://refiddle.com/1ox

Vous aurez du mal à gérer les numéros internationaux avec une regex simple / simple, voir cet article sur les difficultés des numéros de téléphone internationaux (et même nord-américains).

Vous voudrez analyser les premiers chiffres pour déterminer le code de pays, puis agir différemment en fonction du pays.

Au-delà de cela - la liste que vous avez donnée n'inclut pas un autre format commun aux États-Unis - en laissant le 1 d'origine. La plupart des téléphones cellulaires aux États-Unis n'en ont pas besoin, et cela va déconcerter la jeune génération à moins qu'elle l'ait composé internationalement.

Vous avez correctement identifié qu'il s'agissait d'un problème épineux ...

-Adam

Voici un modèle merveilleux qui correspond le mieux à la validation que je devais réaliser. Je ne suis pas l'auteur original, mais je pense que cela vaut la peine de le partager car j'ai trouvé ce problème très complexe et sans réponse concise ou très utile.

Les expressions rationnelles suivantes reprennent les combinaisons de chiffres et de caractères largement utilisées dans divers formats de numéros de téléphone:

/ ^ \ s * (?: \ +? (\ d {1,3}))? ([-. (] * (\ d {3}) [-.)] *)? ((\ d {3}) [-.] * (\ d {2,4}) (?: [-. x] * (\ d +))?) \ s * $ / gm

Positif:
+42 555.123.4567
+ 1- (800) -123-4567
+7 555 1234567
+7 (926) 1234567
(926) 1234567
+79261234567
926 1234567
9261234567
1234567
123-4567
123-89-01
495 1234567
469 123 45 67
89261234567
8 (926) 1234567
926.123.4567
415-555-1234
650-555-2345
(416)555-3456
202 555 4567
4035555678
1 416 555 9292

Négatif:
926 3 4
8 800 600-APPLE

Source originale: http://www.regexr.com/38pvb

Voici mon meilleur essai jusqu'à présent. Il gère les formats ci-dessus, mais je suis sûr qu'il me manque d'autres formats possibles.

^\d?(?:(?:[\+]?(?:[\d]{1,3}(?:[ ]+|[\-.])))?[(]?(?:[\d]{3})[\-/)]?(?:[ ]+)?)?(?:[a-zA-Z2-9][a-zA-Z0-9 \-.]{6,})(?:(?:[ ]+|[xX]|(i:ext[\.]?)){1,2}(?:[\d]{1,5}))?$

Après avoir lu ces réponses, il semble qu’il n’y avait pas d’expression régulière simple qui puisse analyser un tas de textes et extraire les numéros de téléphone de n’importe quel format (y compris les caractères internationaux avec et sans le signe plus).

Voici ce que j'ai utilisé récemment pour un projet client, où nous avons dû convertir tous les numéros de téléphone de tous les formats en tel: links.

Jusqu'à présent, cela fonctionne avec tout ce qu'ils ont jeté, mais si des erreurs se produisent, je mettrai à jour cette réponse.

Regex:

/ (\ + * \ d {1,}) * ([| \ (]) * (\ d {3}) [^ \ d] * (\ d {3}) [^ \ d] * (\ d {4}) /

Fonction PHP pour remplacer tous les numéros de téléphone par des liens tel: (au cas où quelqu'un serait curieux):

function phoneToTel($number) {
    $return = preg_replace('/(\+*\d{1,})*([ |\(])*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4})/', '<a href="tel:$1$3$4$5">$1 ($3) $4-$5</a>', $number); // includes international
    return $return;
}

Je crois que le numéro :: téléphone :: États-Unis et Regexp :: Common (en particulier la source de Expression rationnelle: Commun :: URI :: RFC2806 ) Les modules Perl pourraient aider.

La question devrait probablement être spécifiée un peu plus en détail pour expliquer le but de la validation des nombres. Par exemple, 911 est un nombre valide aux États-Unis, mais 911x ne s'applique à aucune valeur de x. C’est pour que la compagnie de téléphone puisse calculer le moment où vous avez composé le numéro. Il existe plusieurs variantes sur ce problème. Mais votre regex ne vérifie pas la partie de l'indicatif régional, donc cela ne semble pas être un problème.

Comme pour la validation des adresses e-mail, même si vous obtenez un résultat valide, vous ne pouvez pas savoir s'il est attribué à quelqu'un avant de l'avoir essayé.

Si vous essayez de valider la saisie de l'utilisateur, pourquoi ne pas normaliser le résultat et en finir? Si l'utilisateur entre un nombre que vous ne pouvez pas reconnaître comme un nombre valide, sauvegardez-le comme saisie ou supprimez les caractères indisponibles. Le numéro :: téléphone :: normaliser Le module Perl pourrait être une source d’inspiration.

Je travaille pour une entreprise d’études de marché et nous devons filtrer ces types d’intrants à tout moment. Tu compliques trop. Il suffit de supprimer les caractères non alphanumériques et de voir s’il existe une extension.

Pour une analyse plus approfondie, vous pouvez vous abonner à l'un des nombreux fournisseurs qui vous donneront accès à une base de données de numéros valides et vous indiquer s'ils sont fixes ou mobiles, déconnectés, etc. Cela coûte de l'argent.

Remplacez les caractères de formatage, puis vérifiez la validité du téléphone restant. En PHP,

 $replace = array( ' ', '-', '/', '(', ')', ',', '.' ); //etc; as needed
 preg_match( '/1?[0-9]{10}((ext|x)[0-9]{1,4})?/i', str_replace( $replace, '', $phone_num );

Casser une expression rationnelle complexe comme celle-ci peut être tout aussi efficace, mais beaucoup plus simple.

J'ai trouvé que c'était quelque chose d'intéressant. Je ne l'ai pas testé, mais il semble que cela fonctionnerait

<?php
/*
string validate_telephone_number (string $number, array $formats)
*/

function validate_telephone_number($number, $formats)
{
$format = trim(ereg_replace("[0-9]", "#", $number));

return (in_array($format, $formats)) ? true : false;
}

/* Usage Examples */

// List of possible formats: You can add new formats or modify the existing ones

$formats = array('###-###-####', '####-###-###',
                 '(###) ###-###', '####-####-####',
                 '##-###-####-####', '####-####', '###-###-###',
                 '#####-###-###', '##########');

$number = '08008-555-555';

if(validate_telephone_number($number, $formats))
{
echo $number.' is a valid phone number.';
}

echo "<br />";

$number = '123-555-555';

if(validate_telephone_number($number, $formats))
{
echo $number.' is a valid phone number.';
}

echo "<br />";

$number = '1800-1234-5678';

if(validate_telephone_number($number, $formats))
{
echo $number.' is a valid phone number.';
}

echo "<br />";

$number = '(800) 555-123';

if(validate_telephone_number($number, $formats))
{
echo $number.' is a valid phone number.';
}

echo "<br />";

$number = '1234567890';

if(validate_telephone_number($number, $formats))
{
echo $number.' is a valid phone number.';
}
?>

Il serait probablement préférable d’utiliser une entrée masquée pour cela. De cette façon, les utilisateurs peuvent SEULEMENT entrer des chiffres et vous pouvez formater comme bon vous semble. Je ne suis pas sûr que ce soit pour une application Web, mais si c'est le cas, il existe un plugin très clic jQuery qui offre certaines options pour le faire.

http://digitalbush.com/projects/masked-input-plugin/

Ils expliquent même comment masquer les entrées de numéro de téléphone dans leur tutoriel.

En voici un qui fonctionne bien en JavaScript. C'est dans une chaîne parce que c'est ce à quoi s'attendait le widget Dojo.

Il correspond à un numéro NANP nord-américain à 10 chiffres avec extension facultative. Les espaces, les tirets et les points sont des délimiteurs acceptés.

"^(\\(?\\d\\d\\d\\)?)( |-|\\.)?\\d\\d\\d( |-|\\.)?\\d{4,4}(( |-|\\.)?[ext\\.]+ ?\\d+)?<*>quot;

Je me débattais avec le même problème, essayant de rendre ma candidature à l'épreuve du temps, mais ces gars-là m'ont fait aller dans la bonne direction. Je ne vérifie pas le numéro lui-même pour voir s'il fonctionne ou non, j'essaie simplement de m'assurer qu'une série de numéros a été entrée, avec ou sans extension.

Dans le pire des cas, si l'utilisateur devait extraire un numéro non formaté du fichier XML, il ne lui suffirait pas de taper les numéros dans le pavé numérique du téléphone 012345678x5 , sans véritable raison de le conserver. Ce genre de RegEx produirait quelque chose comme ça pour moi:

\d+ ?\w{0,9} ?\d+

01234467 extension 123456
01234567x123456
01234567890

Mon penchant est d’accord pour accepter de ne pas prendre de chiffres et d’accepter simplement ce qui est meilleur. Peut-être pour assurer que quelques chiffres au moins sont présents, bien que cela interdise quelque chose comme un numéro de téléphone alphabétique "ASK-JAKE". par exemple.

Quelques expressions perl simples peuvent être:

@f = /(\d+)/g;
tr/0-9//dc;

Utilisez le premier pour conserver les groupes de chiffres ensemble, ce qui peut donner des indices de formatage. Utilisez le second pour lancer trivialement tous les autres chiffres.

Vous inquiétez-vous du fait qu'il peut être nécessaire de faire une pause puis de saisir d'autres clés? Ou quelque chose comme 555-1212 (attendez le bip) 123?

    pattern="^[\d|\+|\(]+[\)|\d|\s|-]*[\d]<*>quot; 
    validateat="onsubmit"

Doit se terminer par un chiffre, peut commencer par (ou + ou un chiffre et peut contenir + - (ou)

Pour ceux qui souhaitent utiliser des numéros de téléphone mobiles irlandais similaires, voici un moyen simple de le réaliser:

http://ilovenicii.com/?p=87

PHP

<?php
$pattern = "/^(083|086|085|086|087)\d{7}$/";
$phone = "087343266";

if (preg_match($pattern,$phone)) echo "Match";
else echo "Not match";

Il existe également une solution JQuery sur ce lien.

EDIT:

Solution jQuery:

    $(function(){
    //original field values
    var field_values = {
            //id        :  value
            'url'       : 'url',
            'yourname'  : 'yourname',
            'email'     : 'email',
            'phone'     : 'phone'
    };

        var url =$("input#url").val();
        var yourname =$("input#yourname").val();
        var email =$("input#email").val();
        var phone =$("input#phone").val();


    //inputfocus
    $('input#url').inputfocus({ value: field_values['url'] });
    $('input#yourname').inputfocus({ value: field_values['yourname'] });
    $('input#email').inputfocus({ value: field_values['email'] }); 
    $('input#phone').inputfocus({ value: field_values['phone'] });



    //reset progress bar
    $('#progress').css('width','0');
    $('#progress_text').html('0% Complete');

    //first_step
    $('form').submit(function(){ return false; });
    $('#submit_first').click(function(){
        //remove classes
        $('#first_step input').removeClass('error').removeClass('valid');

        //ckeck if inputs aren't empty
        var fields = $('#first_step input[type=text]');
        var error = 0;
        fields.each(function(){
            var value = $(this).val();
            if( value.length<12 || value==field_values[$(this).attr('id')] ) {
                $(this).addClass('error');
                $(this).effect("shake", { times:3 }, 50);

                error++;
            } else {
                $(this).addClass('valid');
            }
        });        

        if(!error) {
            if( $('#password').val() != $('#cpassword').val() ) {
                    $('#first_step input[type=password]').each(function(){
                        $(this).removeClass('valid').addClass('error');
                        $(this).effect("shake", { times:3 }, 50);
                    });

                    return false;
            } else {   
                //update progress bar
                $('#progress_text').html('33% Complete');
                $('#progress').css('width','113px');

                //slide steps
                $('#first_step').slideUp();
                $('#second_step').slideDown();     
            }               
        } else return false;
    });

    //second section
    $('#submit_second').click(function(){
        //remove classes
        $('#second_step input').removeClass('error').removeClass('valid');

        var emailPattern = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/;  
        var fields = $('#second_step input[type=text]');
        var error = 0;
        fields.each(function(){
            var value = $(this).val();
            if( value.length<1 || value==field_values[$(this).attr('id')] || ( $(this).attr('id')=='email' && !emailPattern.test(value) ) ) {
                $(this).addClass('error');
                $(this).effect("shake", { times:3 }, 50);

                error++;
            } else {
                $(this).addClass('valid');
            }


        function validatePhone(phone) {
        var a = document.getElementById(phone).value;
        var filter = /^[0-9-+]+$/;
            if (filter.test(a)) {
                return true;
            }
            else {
                return false;
            }
        }

        $('#phone').blur(function(e) {
            if (validatePhone('txtPhone')) {
                $('#spnPhoneStatus').html('Valid');
                $('#spnPhoneStatus').css('color', 'green');
            }
            else {
                $('#spnPhoneStatus').html('Invalid');
            $('#spnPhoneStatus').css('color', 'red');
            }
        });

     });

        if(!error) {
                //update progress bar
                $('#progress_text').html('66% Complete');
                $('#progress').css('width','226px');

                //slide steps
                $('#second_step').slideUp();
                $('#fourth_step').slideDown();     
        } else return false;

    });


    $('#submit_second').click(function(){
        //update progress bar
        $('#progress_text').html('100% Complete');
        $('#progress').css('width','339px');

        //prepare the fourth step
        var fields = new Array(
            $('#url').val(),
            $('#yourname').val(),
            $('#email').val(),
            $('#phone').val()

        );
        var tr = $('#fourth_step tr');
        tr.each(function(){
            //alert( fields[$(this).index()] )
            $(this).children('td:nth-child(2)').html(fields[$(this).index()]);
        });

        //slide steps
        $('#third_step').slideUp();
        $('#fourth_step').slideDown();            
    });


    $('#submit_fourth').click(function(){

        url =$("input#url").val();
        yourname =$("input#yourname").val();
        email =$("input#email").val();
        phone =$("input#phone").val();

        //send information to server
        var dataString = 'url='+ url + '&yourname=' + yourname + '&email=' + email + '&phone=' + phone;  



        alert (dataString);//return false;  
            $.ajax({  
                type: "POST",  
                url: "http://clients.socialnetworkingsolutions.com/infobox/contact/",  
                data: "url="+url+"&yourname="+yourname+"&email="+email+'&phone=' + phone,
                cache: false,
                success: function(data) {  
                    console.log("form submitted");
                    alert("success");
                }
                });  
        return false;

   });


    //back button
    $('.back').click(function(){
        var container = $(this).parent('div'),
        previous  = container.prev();

        switch(previous.attr('id')) {
            case 'first_step' : $('#progress_text').html('0% Complete');
                  $('#progress').css('width','0px');
                       break;
            case 'second_step': $('#progress_text').html('33% Complete');
                  $('#progress').css('width','113px');
                       break;

            case 'third_step' : $('#progress_text').html('66% Complete');
                  $('#progress').css('width','226px');
                       break;

        default: break;
    }

    $(container).slideUp();
    $(previous).slideDown();
});


});

Source .

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow