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

J'ai trouvé ce code sur un site Web et cela fonctionne parfaitement. Il valide que le numéro de téléphone est dans l'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 des trucs de client) veut ajouter un autre format, les dix nombres consécutifs, quelque chose comme ceci: 1234567890 .

J'utilise cette expression régulière,

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

Comment puis-je ajouter qu'il valide également l'autre format? Je ne suis pas doué pour les expressions régulières.

Tout d'abord, votre validateur de format n'est évidemment approprié que pour les numéros NANP (indicatif de pays +1). Votre application sera-t-elle utilisée par une personne possédant un numéro de téléphone de l'extérieur de l'Amérique du Nord? Si tel est le cas, vous ne voulez pas empêcher ces personnes d'entrer un numéro [international] parfaitement valide.

Deuxièmement, votre validation est incorrecte. Les numéros NANP prennent la forme NXX NXX XXXXoù Nest un chiffre 2-9 et Xest un chiffre 0-9. De plus, les indicatifs régionaux et les échanges peuvent ne pas prendre la forme N11(se terminer par deux) pour éviter toute confusion avec des services spéciaux, sauf que les numéros d'un indicatif régional non géographique (800, 888, 877, 866, 855, 900) peuvent avoir un N11échange.

Donc, votre regex passera le numéro (123) 123 4566 même si ce n'est pas un numéro de téléphone valide. Vous pouvez résoudre ce problème en le remplaçant \d{3}par [2-9]{1}\d{2}.

Enfin, j'ai le sentiment que vous validez l'entrée utilisateur dans un navigateur Web. N'oubliez pas que la validation côté client n'est qu'une commodité que vous fournissez à l'utilisateur ; vous devez encore valider toutes les entrées (à nouveau) sur le serveur.

TL; DR n'utilise pas d'expression régulière pour valider des données complexes du monde réel telles que des numéros de téléphone ou des URL . Utilisez une bibliothèque spécialisée .

Mon 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

Si vous recherchez 10 et seulement 10 chiffres, ignorez tout sauf les chiffres-

   return value.match(/\d/g).length===10;

Ce que je ferais, c'est ignorer le format et valider le contenu numérique:

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);
}

/^[+]*[(]{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 une option très lâche et je préfère la conserver ainsi, je l'utilise principalement dans les formulaires d'inscription où les utilisateurs doivent ajouter leur numéro de téléphone. Habituellement, les utilisateurs ont des problèmes avec les formulaires qui appliquent des règles de formatage strictes, je préfère que l'utilisateur remplisse le numéro et le formate à l'écran ou avant de l'enregistrer dans la base de données. http://regexr.com/3c53v

Le REGEX suivant validera 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}$/

Je suggérerais d'utiliser quelque chose de plus clair (en particulier en pensant à qui devra maintenir le code) ... qu'en est-il:

var formats = "(999)999-9999|999-999-9999|9999999999";
var r = RegExp("^(" +
               formats
                 .replace(/([\(\)])/g, "\\$1")
                 .replace(/9/g,"\\d") +
               ")$");

où l'expression rationnelle est construite à partir d'un modèle clair? Ajouter un nouveau serait alors une évidence et peut-être même le client lui-même pourrait être en mesure de le faire dans une page "options".

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

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");

Essayez celui-ci - il inclut également la validation pour les formats internationaux.

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

Cette regex valide le format suivant:

• (541) 754-3010 Domestique
• + 1-541-754-3010 International
• 1-541-754-3010 Composé aux États-Unis
• 001-541-754-3010 Appelé depuis l'Allemagne
• 191541754 3010 Appelé depuis la France

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

Bien que ce post soit un vieux mais je veux laisser ma contribution. 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

ceux-ci ne sont pas acceptés:

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

5555555 -> pour 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");

Cela fonctionnera:

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

Le ?caractère signifie que le groupe précédent doit être mis en correspondance zéro ou une fois. Le groupe (-|\s)correspondra à -un |caractère ou à un caractère. L'ajout ?après la deuxième occurrence de ce groupe dans votre regex vous permet de faire correspondre une séquence de 10 chiffres consécutifs.

vraiment simple

"9001234567".match(/^\d{10}$/g)

Les réponses de tout le monde sont excellentes, mais en voici une qui, je pense, est un peu plus complète ...

Ceci est écrit pour l'utilisation de correspondance javascript d'un seul numéro sur 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 faire correspondre les limites des mots, remplacez simplement ^ et $ par \ b

J'apprécie toute suggestion, correction ou critique de cette solution. Pour autant que je sache, cela correspond au format NANP (pour les numéros américains - je n'ai pas validé d'autres pays d'Amérique du Nord lors de la création), évite les erreurs 911 (ne peut pas être dans l'indicatif régional ou l'indicatif régional), élimine seulement les 555 numéros qui sont réellement invalides (code régional de 555 suivi de 01xx où x = n'importe quel nombre).

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

Le ?caractère signifie que le groupe précédent doit être mis en correspondance zéro ou une fois. Le groupe (-|\s)correspondra à -un |caractère ou à un caractère.

Je dois admettre que la validation des numéros de téléphone est une tâche difficile. En ce qui concerne ce problème spécifique, je changerais l'expression régulière de

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

à

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

comme le seul élément supplémentaire qui devient inutile est le dernier tiret / espace.

Si vous utilisez une balise d'entrée, ce code vous aidera. J'écris ce code moi-même et je pense que c'est un très bon moyen de l'utiliser en entrée. mais vous pouvez le modifier en utilisant votre format. Cela aidera l'utilisateur à corriger son format sur la balise d'entrée.

$("#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;
}

Je voulais juste ajouter une solution spécifiquement pour la sélection de numéros de téléphone non locaux (types 800 et 900).

(\+?1[-.(\s]?|\()?(900|8(0|4|5|6|7|8)\3+)[)\s]?[-.\s]?\d{3}[-.\s]?\d{4}

Ce reg ex convient aux numéros de téléphone internationaux et aux formats multiples de numéros de téléphone portable.

Voici 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 tirets à la place d'un 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 d'espaces sauf qu'aucun trait d'union ne peut exister directement avant ou après le (0) et l'espace avant ou après le (0) n'a pas besoin d'exister)

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

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

123 123456 (l'espace peut être remplacé par un tiret)

1234567890

Aucun espace double ou double trait d'union ne peut exister pour tous les formats.

Valider le numéro de téléphone + retourner les données formatées

function validTel(str){
  str = str.replace(/[^0-9]/g, '');
  var l = str.length;
  if(l<10) return ['error', 'Tel number length < 10'];
  
  var tel = '', num = str.substr(-7),
      code = str.substr(-10, 3),
      coCode = '';
  if(l>10) {
    coCode = '+' + str.substr(0, (l-10) );
  }
  tel = coCode +' ('+ code +') '+ num;
  
  return ['succes', tel];
}

console.log(validTel('+1 [223] 123.45.67'));

essaye ça

/ ^ (\ + {0,}) (\ d {0,}) ([(] {1} \ d {1,3} [)] {0,}) {0,} (\ s? \ D + | \ + \ d {2,3} \ s {1} \ d + | \ d +) {1} [\ s | -]? \ d + ([\ s | -]? \ d +) {1,2} ( \ s) {0,} $ / g

formats valides

• (123) 456-7890
• (123)456-7890
• 123-456-7890
• 1234567890
• +31636363634
• +3 (123) 123-12-12
• +3 (123) 123-12-12
• +3 (123) 1231212
• +3 (123) 12312123
• +3 (123) 123 12 12
• 075-63546725
• +7910120 54 54
• 910 120 54 54
• 8 999 999 99 99

https://regex101.com/r/QXAhGV/1

Cette fonction a bien fonctionné pour nous:

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-9883208806'));

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

Vérifiez le format, espérons que cela fonctionne:
444-555-1234
f: 246.555.8888
m: 1235554567

\\(?\d{3}\\)?([\-\s\.])?\d{3}\1?\d{4}

Cela validera tout numéro de téléphone de format variable:

\\(?\d{3}\\)? trouve 3 chiffres entre parenthèses ou non.

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

\d{3} trouve 3 chiffres

\1utilise le premier séparateur correspondant - cela garantit que les séparateurs sont identiques. Donc (000) 999-5555 ne validera pas ici car il y a un séparateur d'espace et de tiret, donc supprimez simplement le "\ 1" et remplacez-le par le sous-motif de séparateur (cela validera également les formats non standard). Cependant, vous devez quand même indiquer le format des entrées utilisateur.

\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 pour doubler les échappements.

Essayez cette fonction js. Renvoie vrai s'il correspond et faux s'il échoue Ref

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

Ignorez tout sauf les chiffres.

Voici ce que j'utilise:

// USA phones should contain at least 10 digits. For Ukrainian phones it's OK to have only 9 digits, without leading 0 and country code prefix: [+380] 88 888-88-88.
String.prototype.isValidPhone = function(digitsCount) {
  var str = this.trim().match(/\d/g);
  return str && str.length >= (digitsCount || 10); // default is at least 10 digits
}

essaye ça

/^[\+]?\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