il s'avère qu'il y a quelque chose d'une spécification pour cela, au moins pour L'Amérique du Nord, appelé le NANP .

Vous devez spécifier exactement ce que vous voulez. Que sont les délimiteurs? Des espaces, des tirets et des points? Pas de délimiteur autorisé? Peut-on utiliser des délimiteurs de mélange (par exemple, +0.111-222.3333)? Comment les prorogations (p. ex. 111-222-3333 x 44444) seront-elles traitées? Et les numéros spéciaux, comme le 911? L'indicatif régional sera-t-il facultatif ou obligatoire?

voici un regex pour un nombre à 7 ou 10 chiffres, avec des extensions permises, les délimiteurs sont des espaces, des tirets, ou des périodes:

^(?:(?:\+?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+))?$

"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ère également de regarder la " libphonenumber " Google Library. Je sais que ce n'est pas regex mais ça fait exactement ce que tu veux.

par exemple, il reconnaîtra que:

15555555555

est un nombre, mais pas un nombre valide. Elle soutient également des pays autres que les États-Unis.

faits Saillants de la fonctionnalité:

• Analyse/mise en forme/validation des numéros de téléphone de tous les pays/toutes les régions du monde.
• getNumberType - obtient le type de numéro basé sur le numéro lui-même; capable de distinguer fixe, Mobile, sans frais, à taux majoré, à frais partagés, VoIP et numéros personnels (lorsque possible).
• isNumberMatch - obtient un niveau de confiance sur la question de savoir si deux nombres peuvent être les mêmes.
• getExampleNumber / getExampleNumberByType - fournit des exemples de numéros pour tous les pays / régions, avec la possibilité de spécifier le type de numéro de téléphone exemple est nécessaire.
• isPossibleNumber - devinez rapidement si un nombre est un phonenumber possible en utilisant seulement l'information de longueur, beaucoup plus rapide qu'une validation complète.
• isValidNumber - validation complète d'un numéro de téléphone pour une région à l'aide de renseignements sur la longueur et le préfixe.
• AsYouTypeFormatter - formats numéros de téléphone à la volée lorsque l'utilisateur entre chaque chiffre.
• findNumbers - recherche des nombres dans la saisie de texte.
• PhoneNumberOfflineGeocoder - fournit des renseignements géographiques liés à un numéro de téléphone.

exemples

le plus gros problème avec la validation du numéro de téléphone est qu'il est très dépendant de la culture.

• l'Amérique
  • (408) 974–2042 est un valide NOUS nombre de
  • (999) 974–2042 est pas valide NOUS nombre de
• Australie
  • 0404 999 999 est un valide numéro Australien
  • (02) 9999 9999 est aussi un valide Australien nombre
  • (09) 9999 9999 est pas valide Australien nombre

une expression régulière est bien pour vérifier le format d'un numéro de téléphone, mais il ne va pas vraiment être en mesure de vérifier la validité d'un numéro de téléphone.

je suggère de sauter une simple expression régulière pour tester votre numéro de téléphone, et en utilisant une bibliothèque telle que Google libphonenumber (lien vers le projet GitHub) .

Voici libphonenumber!

en utilisant l'un de vos exemples les plus complexes, 1-234-567-8901 x1234 , vous obtenez les données suivantes de libphonenumber (lien vers la démo 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 (ce qui est), mais vous obtenez également le formatage de numéro de téléphone cohérent dans votre locale.

comme un bonus, libphonenumber a un certain nombre de données pour vérifier la validité des numéros de téléphone, ainsi en vérifiant un numéro tel que +61299999999 (la version internationale de (02) 9999 9999 ) retourne comme un nombre valide avec 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 donne également de nombreux avantages supplémentaires, tels que l'obtention de l'emplacement que le numéro de téléphone est détecté comme étant, et aussi obtenir l'information de fuseau horaire de le 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 invalide ( (09) 9999 9999 ) renvoie 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 a le code pour Java et Javascript, mais les gens ont également mis en œuvre des bibliothèques pour d'autres langues qui utilisent L'ensemble de données de numéro de téléphone Google i18n:

• PHP : https://github.com/giggsey/libphonenumber-for-php
• Python : https://github.com/daviddrysdale/python-phonenumbers
• Ruby : https://github.com/sstephenson/global_phone
• c# : https://github.com/twcclegg/libphonenumber-csharp
• objectif-C : https://github.com/iziz/libPhoneNumber-iOS
• JavaScript : https://github.com/ruimarinho/google-libphonenumber

à moins que vous ne soyez certain que vous allez toujours accepter des nombres à partir d'un seul endroit, et ils vont toujours être dans un format, je suggérerais fortement de ne pas écrire votre propre code pour cela, et en utilisant libphonenumber pour valider et afficher les numéros de téléphone.

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

ce qui 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 sauve:

1. indicateur Pays
2. numéro de téléphone
3. Extension

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

bien que la réponse à strip all whitespace est soignée, elle ne résout pas vraiment le problème qui est posé, qui est de trouver un regex. Prenez, par exemple, mon script de test qui télécharge une page web et extrait tous les numéros de téléphone en utilisant le regex. Puisque vous avez besoin d'un regex de toute façon, vous pourriez aussi bien avoir le regex faire tout le travail. J'ai trouvé 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 la correspondance, 1 $ contient l'indicatif régional, 2 $et 3 $ contiennent le numéro de téléphone, et 5 $ contient le poste. Mon script de test télécharge un fichier à partir d'internet et imprime tous les numéros de téléphone.

#!/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 [--]\n" if not defined ;
                print "match [-- ]\n" if defined ;
        }
        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   \n";
        }
}

Edit:

vous pouvez changer \W* en \s*\W?\s* dans le regex pour le resserrer un peu. Je ne pensais pas au regex en termes de, disons, valider les entrées de l'utilisateur sur un formulaire quand je l'ai écrit, mais ce changement rend possible d'utiliser le regex à 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 ma réponse aussi comme une réponse sur ce fil, parce que personne ne s'adressait comment exiger/ne pas exiger des éléments, juste distribuer des regexs: Regex de travail de mal, de la correspondance, des choses inattendues

à partir de mon post sur ce site, j'ai créé un guide rapide pour aider n'importe qui à faire leur propre regex pour leur propre format de numéro de téléphone désiré, que je vais mettre en garde (comme je did sur l'autre site) que si vous êtes trop restrictif, vous ne pouvez pas obtenir les résultats souhaités, et il n'y a pas de solution "Taille unique" pour accepter tous les numéros de téléphone possibles dans le monde - Seulement ce que vous décidez d'accepter comme votre format de choix. Utilisez à vos propres risques.

• Démarrer l'expression: /^
• si vous souhaitez avoir besoin d'un espace, utilisez: [\s] ou \s
• si vous voulez Demander une parenthèse, utilisez: [(] et [)] . Utiliser \( et \) est laid et peut rendre les choses confuses.
• si vous voulez que quelque chose soit optionnel, mettez un ? après
• si vous voulez un trait d'Union, tapez - ou [-] . Si vous ne le mettez pas en premier ou en dernier dans une série d'autres caractères, cependant, vous pourriez avoir besoin de s'échapper: \-
• si vous voulez accepter des choix différents dans une fente, placez des crochets autour des options: [-.\s] exigera un trait d'Union, une période ou un espace. Un point d'interrogation après la dernière parenthèse rendra toutes ces Options optionnelles pour cette fente.
• \d{3} : nécessite un numéro à 3 chiffres: 000-999. Un raccourci pour [0-9][0-9][0-9] .
• [2-9] : nécessite un chiffre 2-9 pour cette fente.
• (\+|1\s)? : Accepter un "plus" ou un " 1 "et un espace (caractère", | , "ou"), et la rendre facultative. Le signe" plus " doit être échappé.
• si vous voulez que des nombres spécifiques correspondent à une fente, entrez-les: [246] exigera un 2, 4, ou 6. [77|78] aura besoin de 77 ou 78.
• $/ : fin de l'expression

j'ai écrit simplifest (bien que je n'ai pas eu besoin de point dans elle).

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

comme mentionné ci-dessous, il ne vérifie que les caractères, et non sa structure/ordre

notez que la suppression des caractères () ne fonctionne pas pour un style d'écriture des numéros UK qui est commun: +44 (0) 1234 567890 qui signifie composer soit le numéro international:

+441234567890

ou au Royaume-Uni composer 01234567890

si vous voulez juste vérifier que vous n'avez pas de déchets aléatoires dans le champ (c.-à-d., des spammeurs de formulaire) ce regex devrait faire bien:

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

notez qu'il n'a pas de règles spéciales pour le nombre de chiffres, ou quels numéros sont valides dans ces chiffres, il vérifie juste que seuls les chiffres, les parenthèses, les tirets, plus, l'espace, Livre, astérisque, période, virgule, ou les lettres e , x , t sont présents.

It doit être compatible avec les numéros internationaux et les formats de localisation. Ressentez-vous la nécessité de permettre à carré, bouclés, ou chevrons pour certaines régions? (actuellement, ils ne sont pas inclus).

si vous voulez maintenir des règles par chiffre (comme aux États-Unis les codes régionaux et les préfixes (codes d'échange) doivent tomber dans la gamme de 200-999) Eh bien, bonne chance à vous. Le maintien d'un ensemble complexe de règles qui pourraient être dépassées à n'importe quel moment dans l'avenir par n'importe quel pays dans le monde ne son plaisir.

et tout en effaçant tous/la plupart des caractères non numériques peut fonctionner du côté du serveur (surtout si vous prévoyez de passer ces valeurs à un composeur), vous pouvez ne pas vouloir écraser l'entrée de l'utilisateur pendant la validation, en particulier si vous voulez qu'ils apportent des corrections dans un autre champ.

avez-vous regardé RegExLib ?

L'entrée du numéro de téléphone nous a rapporté une liste de possibilités.

j'ai trouvé que cela fonctionne assez bien:

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

il fonctionne pour ces formats de nombre:

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

assurez-vous d'utiliser les drapeaux global et multiligne pour être sûr.

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

si vous parlez de validation de formulaire, le regexp pour valider la signification correcte aussi bien que les données correctes va être extrêmement complexe en raison des normes variables de pays et de fournisseur. Il sera également difficile de se tenir à jour.

j'interprète la question comme la recherche d'un large motif valable, ce qui peut ne pas être une cohérence interne - par exemple, un ensemble valide de chiffres, mais pas de valider que le tronc ligne, bourse, etc. au motif valable pour le préfixe de code de pays.

L'Amérique du Nord est simple, et pour international je préfère utiliser un modèle "idiomatique" qui couvre les façons dont les gens précisent et se souviennent de leurs numéros:

^((((\(\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 fait en sorte que si une parenthèse est incluse les deux sont. L'international comptabilise un " + " Initial facultatif et un code de pays. Après ça, 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é comme mon expérience est limitée à L'Amérique du Nord, L'Europe et un petit peu de L'Asie.

Ma tentative sans entraves regex:

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

accepte:

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

rejette:

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

C'est à vous de désinfecter pour l'affichage. Après la validation il pourrait être un nombre cependant.

il s'agit d'un simple modèle D'Expression régulière pour les numéros de téléphone mobile des Philippines:

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

ou

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

correspond à la ces:

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

le premier correspond à N'importe quel code de pays à deux chiffres, tandis que le second correspond exclusivement au code de pays philippin.

tester ici: http://refiddle.com/1ox

Mon sentiment est renforcé par la quantité de réponses à ce sujet - qu'il existe un nombre infini de solutions à ce problème, mais aucun qui vont être élégant.

Honnêtement, je vous recommande de ne pas essayer de valider les numéros de téléphone. Même si vous pouviez écrire un validateur big hairy qui autoriserait tous les différents formats légitimes, il finirait par autoriser à peu près tout ce qui ressemble même à un numéro de téléphone en premier lieu.

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

, Vous aurez un moment difficile de traiter avec des numéros internationaux avec un seul/simple regex, voir ce post sur les difficultés de l'international (et même en amérique du nord) numéros de téléphone.

vous voudrez analyser les premiers chiffres pour déterminer ce qu'est le code du pays, puis agir différemment basé sur le pays.

au-delà de cela - la liste que vous avez donnée n'inclut pas un autre format US courant-laissant de côté le format initial 1. La plupart des téléphones portables aux États-Unis n'en ont pas besoin, et cela va commencer à déconcerter la jeune génération à moins qu'ils n'aient composé un numéro international.

Vous avez correctement identifié que c'est un problème délicat...

- Adam

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 texte et extraire des numéros de téléphone dans n'importe quel format (y compris international avec et sans le signe plus).

voici ce que j'ai utilisé pour un projet client récemment, où nous avons dû convertir tous les numéros de téléphone dans n'importe quel format à tel: liens.

Jusqu'à présent, ça a marché avec tout ce qu'ils ont jeté dessus, mais si des erreurs se produisent, je vais mettre à 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 tel: links (au cas où quelqu'un est curieux):

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

voici un modèle merveilleux qui correspond le plus étroitement à la validation que je devais obtenir. Je ne suis pas l'auteur original, mais je pense qu'il vaut la peine de partager car j'ai trouvé ce problème très complexe et sans une réponse concise ou largement utile.

le regex suivant saisira des combinaisons de nombres et de caractères largement utilisées dans une variété de formats de numéros de téléphone global:

/^\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
151990920" +79261234567

926 1234567

9261234567

1234567

123-4567

123-89-01

495 1234567

Quatre cent soixante neuf 123 45 67

89261234567

8 (926) 1234567

926.123.4567

415-555-1234

650-555-2345

(416)555-3456

202 555 4567
151990920" 4035555678

1 416 555 9292

négatif:

926 3 4

8 800 600-pomme

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

voici ma meilleure tentative jusqu'à présent. Il gère les formats ci-dessus, mais je suis sûr que je 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}))?$

je crois que le numéro Numéro::Téléphone::US et Regexp::commun (en particulier la source de Regexp::commun::URI::RFC2806 ) modules Perl pourrait aider.

la question devrait probablement être précisée un peu plus en détail pour expliquer l'objet de la validation des nombres. Par exemple, 911 est un nombre valide aux États-Unis, mais 911x n'est pas pour toute valeur de X. C'est pour que la compagnie de téléphone puisse calculer quand tu auras fini de composer. Il y a plusieurs variantes à cette question. Mais votre regex ne vérifie pas la partie code régional, donc ça ne semble pas être un problème.

comme la validation des adresses email, même si vous avez un résultat valide, Vous ne pouvez pas savoir si elle est assignée à quelqu'un jusqu'à ce que vous l'essayez.

si vous essayez de valider les entrées de l'utilisateur, pourquoi ne pas normaliser le résultat et en faire une utilisation? Si l'utilisateur met un nombre que vous ne pouvez pas reconnaître comme valide numéro, soit l'enregistrer comme entrée ou rayer les caractères indisponibles. Le numéro :: téléphone::normaliser module Perl pourrait être une source d'inspiration.

je travaille pour une société d'études de marché et nous devons filtrer ces types d'entrées tout le temps. Vous compliquez trop les choses. Il suffit d'enlever les caractères non alphanumériques, et voir s'il y a 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 ainsi que vous dire si elles sont des lignes fixes ou mobiles, déconnecté, etc Il coûte de l'argent.

faites un remplacement sur le formatage des caractères, puis vérifiez le reste pour la validité du téléphone. 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 );

briser un complexe regexp comme celui-ci peut être tout aussi efficace, mais beaucoup plus simple.

j'ai trouvé ça 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.';
}
?>

vous seriez probablement mieux d'utiliser une entrée masquée pour cela. De cette façon, les utilisateurs ne peuvent entrer que des nombres 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 y a un plugin jQuery qui offre quelques options pour le faire.

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

ils vont même jusqu'à 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 que le widget Dojo attendait.

correspond à un numéro à 10 chiffres du PNNA en Amérique du Nord avec une extension optionnelle. Les espaces, les tirets et les périodes sont des délimiteurs acceptés.

"^(\(?\d\d\d\)?)( |-|\.)?\d\d\d( |-|\.)?\d{4,4}(( |-|\.)?[ext\.]+ ?\d+)?$"

je me débattais avec le même problème, essayant de faire ma demande future preuve, mais ces gars m'a fait aller dans la bonne direction. En fait, je ne vérifie pas le numéro lui-même pour voir s'il fonctionne ou non, j'essaie juste de m'assurer qu'une série de numéros a été entrée qui peuvent ou non avoir une extension.

le pire des scénarios si l'utilisateur devait extraire un numéro non formaté du fichier XML, il taperait tout de même les numéros dans le numberpad 012345678x5 , aucune raison de le garder joli. Ce genre de RegEx sortirait quelque chose comme ça pour moi:

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

• 01234467 extension 123456
• 01234567x123456
• 01234567890

mon penchant est d'être d'accord sur le fait qu'enlever les non-chiffres et simplement accepter ce qu'il y a de mieux. Peut-être pour s'assurer qu'au moins quelques chiffres sont présents, bien que cela interdise quelque chose comme un numéro de téléphone alphabétique "demander-JAKE" par exemple.

quelques expressions perl simples pourraient être:

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

utiliser le premier pour garder les groupes de chiffres ensemble, ce qui peut donner des indices de formatage. Utilisez le deuxième pour jeter tous les non chiffres.

est-ce que c'est un souci qu'il puisse y avoir une pause et ensuite plus de touches saisies? Ou quelque chose comme 555-1212 (attendre le bip) 123?

    pattern="^[\d|\+|\(]+[\)|\d|\s|-]*[\d]$" 
    validateat="onsubmit"

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

pour toute personne intéressée à faire quelque chose de similaire avec les numéros de téléphone mobile Irlandais, voici un moyen simple de l'accomplir:

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 y a aussi une solution JQuery sur ce lien.

EDIT:

jQuery solution:

    $(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 .