Valider votre numéro de téléphone avec JavaScript

J'ai trouvé ce code dans un site web, et il fonctionne parfaitement. Il vérifie que le numéro de téléphone est dans un de ces formats:

(123) 456-7890 ou 123-456-7890

Le problème est que mon client (je ne sais pas pourquoi, peut-être du client fourre) veut ajouter un autre format, les dix numéros consécutifs, quelque chose comme ceci: 1234567890.

Je suis en utilisant cette expression régulière,

/^(\()?\d{3}(\))?(-|\s)?\d{3}(-|\s)\d{4}$/

Comment puis-je ajouter qu'il valide aussi la un autre format? Je ne suis pas bon avec les expressions régulières.

double possible de Une regex complète pour le numéro de téléphone de validation
Comme une règle du pouce pour tenter de valider les numéros de téléphone est vouée à l'échec. Qu'est-ce avec des structures différentes dans les différents pays et les extensions, c'est un problème très difficile.
Et ce que les français notation? "12 34 56 78 90" il suffit de retirer tout sauf des numéros (sauf peut-être un signe plus au début) et vérifiez la longueur.
Vous ne devriez pas, en fait, utiliser des expressions régulières pour valider les numéros de téléphone correctement.

InformationsquelleAutor Castro Roy | 2010-12-02

javascript regex

101

Tout d'abord, le format de votre valideur est évidemment seulement approprié pour PNNA (indicatif de pays +1) nombres. Sera votre application utilisée par quelqu'un avec un numéro de téléphone à partir de l'extérieur de l'Amérique du Nord? Si donc, vous ne voulez pas empêcher ces personnes d'entrer dans un parfaitement valide [international] nombre.

Deuxièmement, votre validation est incorrect. PNNA les numéros prennent la forme NXX NXX XXXX où N est un chiffre de 2 à 9 et X est un chiffre de 0 à 9. En outre, les codes et les échanges ne peuvent pas prendre la forme N11 (à la fin avec les deux) pour éviter la confusion avec les services spéciaux sauf numéros non géographiques de la zone de code (800, 888, 877, 866, 855, 900) peut avoir un N11 échange.

Donc, votre regex va passer le nombre (123) 123 4566 même si ce n'est pas un numéro de téléphone valide. Vous pouvez corriger cela en remplaçant \d{3} avec [2-9]{1}\d{2}.

Enfin, j'ai le sentiment que vous êtes à la validation de la saisie de l'utilisateur dans un navigateur web. Rappelez-vous que la validation côté client est seulement un pratique que vous fournissez à l'utilisateur; vous avez encore besoin de valider la saisie de tous (encore une fois) sur le serveur.

TL;DR ne pas utiliser une expression régulière pour valider complexes du monde réel, des données comme les numéros de téléphone ou Url. Utiliser un bibliothèque spécialisée.
- Je suis d'accord que la regex n'est pas suffisante pour valider les numéros de téléphone parce que le téléphone plan de numérotation fonctionne réellement basée sur la distance, par exemple 12300000 à 12399999 (numberingplans.com/...)
- href="https://code.google.com/p/libphonenumber/" >libphonenumber
InformationsquelleAutor josh3736
110

Ma regex de choix est:
```
/^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$/im
```
Formats valides:

(123) 456-7890

(123)456-7890

123-456-7890

123.456.7890

1234567890

+31636363634

075-63546725
- Qu'est-ce que /im ? Ne peut pas trouver l'explication sur google 🙂
- rend l'expression de la casse et m effectue multi-ligne recherche
- pourquoi auriez-vous besoin de la casse pour les nombres?
- Cette expression est intéressant, parce que si vous retirez le ^ au début et à la $ la fin, on peut trouver les numéros de téléphone au moyen de cordes aussi
- cette regex ne fonctionne pour moi, 123456789 retourne false
InformationsquelleAutor EeeeeK
55

Si vous êtes à la recherche pour le 10 et seulement à 10 chiffres, ignorent tout, mais les chiffres-
```
   return value.match(/\d/g).length===10;
```
- C'est ce que j'allais suggérer. Breezy. Et trop de validation peut être une mauvaise chose de toute façon.
- C'est la meilleure façon d'aller. À moins que vous vous souciez VRAIMENT de quel format il est, tout cela n'est assurez-vous que le nombre est partiellement valide, et non pas un tas de jibberish.
- Tu veux dire match(/\d/g) pas de match(/\d/) ou la longueur sera de 1, pas 10; aussi, le match sur une chaîne vide est nulle. À tout le moins, cela devrait être var m = valeur.match(/\d/g); return m && m.longueur === 10
- Ou return (value.match(/\d/g) || []).length == 10 ou le plus simple (mais tout aussi imparfait): return value.replace(/\D/g,'').length == 10.
- J'aime celui-ci: /\D/gi.test(value). Tout ce qui n'est pas un chiffre, y compris les espaces, tirets, etc...
InformationsquelleAutor kennebec
28

Ce que je voudrais faire est de les ignorer, le format et valider les contenus numériques:
```
var originalPhoneNumber = "415-555-1212";

function isValid(p) {
  var phoneRe = /^[2-9]\d{2}[2-9]\d{2}\d{4}$/;
  var digits = p.replace(/\D/g, "");
  return phoneRe.test(digits);
}
```
- Concernant ignorant mise en forme, .e.g. il est très commun pour les numéros de téléphone mobile pour être présenté avec des espaces comme XXXX XXX XXX mais pour les formulaires d'exiger la saisie sans espaces, c'est à dire que XXXXXXXXXX.
InformationsquelleAutor Paul Schreiber
27

La REGEX suivante permettra de valider l'un de ces formats:

(123) 456-7890

123-456-7890

123.456.7890

1234567890
```
/^[(]{0,1}[0-9]{3}[)]{0,1}[-\s\.]{0,1}[0-9]{3}[-\s\.]{0,1}[0-9]{4}$/
```
- Vous avez besoin d'échapper à la . ou bien il va correspondre à un caractère arbitraire, de casser votre regex.
- Ce qui m'a conduit dans la bonne direction. Merci! Malheureusement, cette expression correspond aussi à la (1234567890 et 123)4567890. ^((([0-9]{3}))|([0-9]{3}))[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4}$ prend soin de ce petit problème.
InformationsquelleAutor Billbad
22
```
/^[+]*[(]{0,1}[0-9]{1,3}[)]{0,1}[-\s\./0-9]*$/g
```
(123) 456-7890

+(123) 456-7890

+(123)-456-7890

+(123) - 456-7890

+(123) - 456-78-90

123-456-7890

123.456.7890

1234567890

+31636363634

075-63546725

C'est très une option lâche et je préfère garder de cette façon, je vais surtout l'utiliser dans les formulaires d'inscription, où les utilisateurs doivent ajouter leur numéro de téléphone.
Habituellement, les utilisateurs ont de la difficulté avec les formulaires d'appliquer strictement les règles de formatage, je préfère l'utilisateur à saisir le nombre et le format à l'écran ou à l'avant de l'enregistrer dans la base de données.
http://regexr.com/3c53v
- regex légèrement modifié pour permettre par exemple pour +41 (79) 123 45 67 (Suisse): /^[+]?[\s./0-9]*[(]?[0-9]{1,4}[)]?[-\s./0-9]*$/g
- Celui-ci semble être un bon ajustement pour moi, car il n'est pas trop chaîne et semble couvrir tous les formats internationaux (et merci @RemigiusStalder pour la Suisse fix)
InformationsquelleAutor elishas
13

Je vous suggérons d'utiliser quelque chose de plus clair (surtout en pensant à qui le code)... que dire de:
```
var formats = "(999)999-9999|999-999-9999|9999999999";
var r = RegExp("^(" +
               formats
                 .replace(/([])/g, "\\\")
                 .replace(/9/g,"\\d") +
               ")$");
```
où la regexp est construit à partir d'un clair de modèle ? L'ajout d'un nouveau serait alors une évidence et peut-être même le client lui-même pourrait être en mesure de le faire en une page "options".

InformationsquelleAutor 6502

Où str pourrait être l'un de ces formarts:
555-555-5555
(555)555-5555
(555) 555-5555
555 555 5555
5555555555
1 555 555 5555

JS:

function telephoneCheck(str) {
  var isphone = /^(1\s|1|)?((\(\d{3}\))|\d{3})(\-|\s)?(\d{3})(\-|\s)?(\d{4})$/.test(str);
  alert(isphone);
}
telephoneCheck("1 555 555 5555");

InformationsquelleAutor Frawel

5

Cela fonctionne:
```
/^(()?\d{3}())?(-|\s)?\d{3}(-|\s)?\d{4}$/
```
La ? caractère signifie que le groupe précédent doivent être fixées à zéro ou une fois. Le groupe (-|\s) va correspondre à un - ou un | caractère. L'ajout de ? après la deuxième occurrence de ce groupe dans votre regex permet de faire correspondre une séquence de 10 chiffres consécutifs.

InformationsquelleAutor Donut
5

Essayer ce qu'il comprend une validation internationale des formats trop.

/^[+]?(1\-|1\s|1|\d{3}\-|\d{3}\s|)?(($\d{3}$)|\d{3})(\-|\s)?(\d{3})(\-|\s)?(\d{4})$/g

Cette expression valide le format suivant:
- (541) 754-3010 Intérieur
- +1-541-754-3010 International
- 1-541-754-3010 Composé dans la NOUS
- 001-541-754-3010 Composé de l'Allemagne
- 191 541 754 3010 Composés à partir de la France
InformationsquelleAutor harinimurugan
3

Tous les réponses sont grands, mais ici, c'est que je pense c'est un peu plus complet...

Ce qui est écrit pour javascript match utilisation d'un seul numéro en une seule ligne:
```
^(?!.*911.*\d{4})((\+?1[\/]?)?(?![$\. -]?555.*)\( ?[2-9][0-9]{2} ?$ ?|(\+?1[\.\/-])?[2-9][0-9]{2}[\.\/-]?)(?!555.?01..)([2-9][0-9]{2})[\.\/-]?([0-9]{4})$
```
Si vous voulez correspondre aux limites des mots, il suffit de changer le ^ et le $ à \b

Je souhaite la bienvenue à toutes les suggestions, des corrections, ou des critiques de cette solution. Aussi loin que je peux dire, correspond à la PNNA format (pour les etats-unis numéros - je n'ai pas de valider d'autres pays d'Amérique du Nord lors de la création de ce), qui évite tout 911 erreurs (ne peut pas être dans la zone de code ou le code de région), élimine seulement ceux 555 numéros qui sont en fait des invalides (code de région 555 suivi par 0.1.xx où x = n'importe quel nombre).

InformationsquelleAutor Erasmus
3

/^\+?1?\s*?$?\d{3}(?:$|[-|\s])?\s*?\d{3}[-|\s]?\d{4}$/

Bien que ce post est vieux, mais l'intention de quitter mon contribuition.
ceux-ci sont acceptés:
5555555555
555-555-5555
(555)555-5555
1(555)555-5555
1 555 555 5555
1 555-555-5555
1 (555) 555-5555

ne sont pas acceptés:

555-5555 -> d'accepter cette utilisation: ^\+?1?\s*?$?(\d{3})?(?:$|[-|\s])?\s*?\d{3}[-|\s]?\d{4}$

5555555 -> d'accepter cette utilisation: ^\+?1?\s*?$?(\d{3})?(?:$|[-|\s])?\s*?\d{3}[-|\s]?\d{4}$

1 555)555-5555
123**&!!asdf#
55555555
(6505552368)
2 (757) 622-7382
0 (757) 622-7382
-1 (757) 622-7382
2 757 622-7382
10 (757) 622-7382
27576227382
(275)76227382
2(757)6227382
2(757)622-7382
(555)5(55?)-5555

c'est le code que j'ai utilisé:
```
function telephoneCheck(str) {
  var patt = new RegExp(/^\+?1?\s*?$?\d{3}(?:$|[-|\s])?\s*?\d{3}[-|\s]?\d{4}$/);
  return patt.test(str);
}

telephoneCheck("+1 555-555-5555");
```
InformationsquelleAutor Flavio Ferreira
2

vraiment simple
```
"9001234567".match(/^\d{10}$/g)
```
InformationsquelleAutor Nikita Shahov
1

/^(()?\d{3}())?(-|\s)?\d{3}(-|\s)?\d{4}$/

La ? caractère signifie que le groupe précédent doivent être fixées à zéro ou une fois. Le groupe (-|\s) va correspondre à un - ou un | caractère.

InformationsquelleAutor parijat
1

Je suis d'accord, la validation des numéros de téléphone est une tâche difficile.
Comme pour ce problème spécifique, je voudrais modifier la regex de
```
/^(()?\d{3}())?(-|\s)?\d{3}(-|\s)\d{4}$/
```
à
```
/^(()?\d{3}())?(-|\s)?\d{3}(-|\s)?\d{4}$/
```
comme le seul élément de plus qui devient inutile est le dernier dash/espace.
- J'essaye vraiment de ma Regex jeu! Je suis la vérification de votre suggestion à l'aide de "La Regex l'Entraîneur." Je suis en utilisant les regex (()?\d{3}())?(-|\s)?\d{3}(-|\s)?\d{4} et la chaîne cible (123) 456-7890 mais pour une raison quelconque, il est seulement l'accaparement des 7 derniers chiffres. Des idées?
- Yep regex sont un peu rugueux sur le cerveau... et de la patience. Ok essayez de /^[(]?(\d{3})[)]?[-|\s]?(\d{3})[-|\s]?(\d{4})$/ la première partie de l'ancienne regex ne doit pas faire bien: "(()?\d{3}())" (() le milieu de la parenthèse était en fait considéré comme faisant partie de la syntaxe regex et pas de caractères à rechercher.
InformationsquelleAutor Luc Veronneau

Si vous utilisez sur les balises d'entrée que ce code va vous aider. J'écris ce code par moi-même et je pense que c'est une très bonne façon de l'utiliser en entrée. mais vous pouvez le modifier à l'aide de votre format. Il va aider l'utilisateur à corriger leur format sur la balise input.

$("#phone").on('input', function() {  //this is use for every time input change.
var inputValue = getInputValue(); //get value from input and make it usefull number
var length = inputValue.length; //get lenth of input
if (inputValue < 1000)
{
inputValue = '1('+inputValue;
}else if (inputValue < 1000000) 
{
inputValue = '1('+ inputValue.substring(0, 3) + ')' + inputValue.substring(3, length);
}else if (inputValue < 10000000000) 
{
inputValue = '1('+ inputValue.substring(0, 3) + ')' + inputValue.substring(3, 6) + '-' + inputValue.substring(6, length);
}else
{
inputValue = '1('+ inputValue.substring(0, 3) + ')' + inputValue.substring(3, 6) + '-' + inputValue.substring(6, 10);
}       
$("#phone").val(inputValue); //correct value entered to your input.
inputValue = getInputValue();//get value again, becuase it changed, this one using for changing color of input border
if ((inputValue > 2000000000) && (inputValue < 9999999999))
{
$("#phone").css("border","black solid 1px");//if it is valid phone number than border will be black.
}else
{
$("#phone").css("border","red solid 1px");//if it is invalid phone number than border will be red.
}
});
function getInputValue() {
var inputValue = $("#phone").val().replace(/\D/g,'');  //remove all non numeric character
if (inputValue.charAt(0) == 1) //if first character is 1 than remove it.
{
var inputValue = inputValue.substring(1, inputValue.length);
}
return inputValue;
}

InformationsquelleAutor

1

Voulais juste ajouter une solution spécifiquement pour la sélection de la non-locales des numéros de téléphone(800 et 900 espèces).
```
(\+?1[-.(\s]?|\()?(900|8(0|4|5|6|7|8)\3+)[)\s]?[-.\s]?\d{3}[-.\s]?\d{4}
```
InformationsquelleAutor Mike T
1

Google a une bonne bibliothèque pour la manipulation des numéros de téléphone en Javascript: https://github.com/googlei18n/libphonenumber. Fonctionne aussi avec Java et C++.

Je préfère utiliser, car celui-ci doit être vraiment bien testé en production. Donc, cela devrait être tout à fait sûr de relais.

InformationsquelleAutor Ville Venäläinen

Cette fonction a travaillé pour nous bien:

JS:

let isPhoneNumber = input => {
try {
let ISD_CODES = [93, 355, 213, 1684, 376, 244, 1264, 672, 1268, 54, 374, 297, 61, 43, 994, 1242, 973, 880, 1246, 375, 32, 501, 229, 1441, 975, 591, 387, 267, 55, 246, 1284, 673, 359, 226, 257, 855, 237, 1, 238, 1345, 236, 235, 56, 86, 61, 61, 57, 269, 682, 506, 385, 53, 599, 357, 420, 243, 45, 253, 1767, 1809, 1829, 1849, 670, 593, 20, 503, 240, 291, 372, 251, 500, 298, 679, 358, 33, 689, 241, 220, 995, 49, 233, 350, 30, 299, 1473, 1671, 502, 441481, 224, 245, 592, 509, 504, 852, 36, 354, 91, 62, 98, 964, 353, 441624, 972, 39, 225, 1876, 81, 441534, 962, 7, 254, 686, 383, 965, 996, 856, 371, 961, 266, 231, 218, 423, 370, 352, 853, 389, 261, 265, 60, 960, 223, 356, 692, 222, 230, 262, 52, 691, 373, 377, 976, 382, 1664, 212, 258, 95, 264, 674, 977, 31, 599, 687, 64, 505, 227, 234, 683, 850, 1670, 47, 968, 92, 680, 970, 507, 675, 595, 51, 63, 64, 48, 351, 1787, 1939, 974, 242, 262, 40, 7, 250, 590, 290, 1869, 1758, 590, 508, 1784, 685, 378, 239, 966, 221, 381, 248, 232, 65, 1721, 421, 386, 677, 252, 27, 82, 211, 34, 94, 249, 597, 47, 268, 46, 41, 963, 886, 992, 255, 66, 228, 690, 676, 1868, 216, 90, 993, 1649, 688, 1340, 256, 380, 971, 44, 1, 598, 998, 678, 379, 58, 84, 681, 212, 967, 260, 263],
//extract numbers from string
thenum = input.match(/[0-9]+/g).join(""),
totalnums = thenum.length,
last10Digits = parseInt(thenum) % 10000000000,
ISDcode = thenum.substring(0, totalnums - 10);
//phone numbers are generally of 8 to 16 digits
if (totalnums >= 8 && totalnums <= 16) {
if (ISDcode) {
if (ISD_CODES.includes(parseInt(ISDcode))) {
return true;
} else {
return false;
}
} else {
return true;
}
}
} catch (e) {}
return false;
}
console.log(isPhoneNumber('91-9773207706'));

InformationsquelleAutor student

1
```
\$?\d{3}\$?([\-\s\.])?\d{3}\1?\d{4}
```
Cela permettra de valider n'importe quel numéro de téléphone de format variable:

\$?\d{3}\$? trouve à 3 chiffres à l'délimitée par des parenthèses ou pas.

([\-\s\.])? trouve l'un de ces caractères de séparation ou de ne pas

\d{3} trouve à 3 chiffres à l'

\1 utilise la première appariés séparateur - ce qui garantit que les séparateurs sont les mêmes. Donc (000) 999-5555 ne validera pas ici car il y a un espace et le tiret séparateur, il suffit donc de retirer le "\1" et le remplacer par le séparateur de sous-modèle (cela permettra également de valider les formats non standard). Vous devez cependant être de format les conseils de la saisie de l'utilisateur de toute façon.

\d{4} trouve à 4 chiffres

Valide:
- (000) 999 5555
- (000)-999-5555
- (000).999.5555
- (000) 999-5555
- (000)9995555
- 000 999 5555
- 000-999-5555
- 000.999.5555
- 0009995555
BTW c'est pour JavaScript donc à double échappe.

InformationsquelleAutor Dacmeaux
1

Ce reg ex est adapté pour les numéros de téléphone internationaux et plusieurs formats de cellule mobile numéros.

Ici est l'expression régulière:
/^(+{1}\d{2,3}\s?[(]{1}\d{1,3}[)]{1}\s?\d+|+\d{2,3}\s{1}\d+|\d+){1}[\s|-]?\d+([\s|-]?\d+){1,2}$/

Voici la fonction JavaScript
```
function isValidPhone(phoneNumber) {
var found = phoneNumber.search(/^(\+{1}\d{2,3}\s?[(]{1}\d{1,3}[)]{1}\s?\d+|\+\d{2,3}\s{1}\d+|\d+){1}[\s|-]?\d+([\s|-]?\d+){1,2}$/);
if(found > -1) {
return true;
}
else {
return false;
}
}
```
Cela valide les formats suivants:

+44 07988-825 465 (avec n'importe quelle combinaison de traits d'union à la place de l'espace, sauf que seul un espace doit suivre le +44)

+44 (0) 7988-825 465 (avec n'importe quelle combinaison de traits d'union à la place des espaces, sauf que pas de trait d'union peut exister directement avant ou après l' (0) et l'espace avant ou après le (0) ne doit pas exister)

123 456-789 0123 (avec n'importe quelle combinaison de traits d'union à la place des espaces)

123-123 123 (avec n'importe quelle combinaison de traits d'union à la place des espaces)

123 123456 (Espace peut être remplacé par un trait d'union)

1234567890

Pas les espaces doubles ou doubles tirets peuvent exister pour tous les formats.

InformationsquelleAutor user2288580
0

Expression Régulière Simple: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g

Vérifier le format, espérons que cela fonctionne :

444-555-1234

f:246.555.8888

m:1235554567
- Veuillez format de votre réponse (à l'aide de quatre espaces comme des tirets pour un bloc de code). Une explication à votre code permettra également d'augmenter sa qualité.
InformationsquelleAutor sahed sawon
0

Il y a trop de regex variantes pour valider un numéro de téléphone. Je recommande cet article: JavaScript: Formulaire HTML - Numéro de Téléphone validation, où de multiples variantes sont indiquées pour chaque cas. Si vous voulez approfondir dans regex pour une expression personnalisée, vous pouvez consulter ce la documentation.

InformationsquelleAutor J.C. Gras
0

Essayer cette fonction js.
Retourne true si elle correspond, et false si elle échoue
Ref

JS:
```
function ValidatePhoneNumber(phone) {
return /^\+?([0-9]{2})\)?[-. ]?([0-9]{4})[-. ]?([0-9]{4})$/.test(phone);
}
```
InformationsquelleAutor joxiah025
0

essayer cette
```
/^[\+]?\d{2,}?[(]?\d{2,}[)]?[-\s\.]?\d{2,}?[-\s\.]?\d{2,}[-\s\.]?\d{0,9}$/im
```
formats valides:
1. (123) 456-7890
2. (123)456-7890
3. 123-456-7890
4. 123.456.7890
5. 1234567890
6. +31636363634
7. +3(123) 123-12-12
8. +3(123)123-12-12
9. +3(123)1231212
10. +3(123) 12312123
11. 075-63546725
- Assurez-vous d'inclure des explications avec votre réponse. Bien qu'il puisse travailler, il est important d'expliquer comment et pourquoi, afin d'avoir une information complète et appropriée. Merci de répondre 🙂
InformationsquelleAutor Maxym

Valider votre numéro de téléphone avec un indien standard, comme démarrer avec seulement 6,7,8 ou 9 et le total des chiffres doit être de 10

La solution est testé et de travail

if(phone=='')       
{
alert("please fill out the field");
}
if ($('#phone').val()!="")
{
if(!phoneno.test(phone)) 
{
alert("enter valid phone number with indian standard.")
exit;
}
else
{
alert("valid phone number");
}
}

InformationsquelleAutor Rohit Kansay

Vous devez vous connecter pour publier un commentaire.