Überprüfen Sie die Telefonnummer mit JavaScript

Ich habe diesen Code auf einer Website gefunden und er funktioniert perfekt. Es wird überprüft, ob die Telefonnummer in einem der folgenden Formate
vorliegt : (123) 456-7890 oder 123-456-7890

Das Problem ist, dass mein Client (ich weiß nicht warum, vielleicht Client-Sachen) ein anderes Format hinzufügen möchte, die zehn Zahlen nacheinander, ungefähr so: 1234567890 .

Ich benutze diesen regulären Ausdruck,

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

Wie kann ich hinzufügen, dass es auch das andere Format validiert? Ich bin nicht gut mit regulären Ausdrücken.

Zunächst einmal ist Ihr Formatprüfer offensichtlich nur für NANP- Nummern (Ländercode +1) geeignet . Wird Ihre Anwendung von jemandem mit einer Telefonnummer außerhalb Nordamerikas verwendet? In diesem Fall möchten Sie nicht verhindern, dass diese Personen eine vollständig gültige [internationale] Nummer eingeben.

Zweitens ist Ihre Validierung falsch. NANP Zahlen die Form , NXX NXX XXXXwo Neine Ziffer 2-9 und Xeine Ziffer 0-9. Außerdem haben Vorwahlen und Vermittlungsstellen möglicherweise nicht die Form N11(Ende mit zwei), um Verwechslungen mit speziellen Diensten zu vermeiden, außer dass Nummern in einer nicht geografischen Vorwahl (800, 888, 877, 866, 855, 900) möglicherweise eine N11Vermittlungsstelle haben.

Ihr regulärer Ausdruck übergibt also die Nummer (123) 123 4566, obwohl dies keine gültige Telefonnummer ist. Sie können das Problem beheben , indem Austausch \d{3}mit [2-9]{1}\d{2}.

Schließlich habe ich das Gefühl, dass Sie Benutzereingaben in einem Webbrowser überprüfen. Denken Sie daran, dass die clientseitige Validierung nur eine Annehmlichkeit ist, die Sie dem Benutzer bieten . Sie müssen noch alle Eingaben (erneut) auf dem Server überprüfen.

TL; DR verwendet keinen regulären Ausdruck, um komplexe reale Daten wie Telefonnummern oder URLs zu validieren . Verwenden Sie eine spezielle Bibliothek .

Mein Regex der Wahl ist:

/^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$/im

Gültige Formate:

(123) 456-7890
(123)456-7890
123-456-7890
123.456.7890
1234567890
+31636363634
075-63546725

Wenn Sie nach 10 und nur 10 Ziffern suchen, ignorieren Sie alles außer den Ziffern.

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

Ich würde das Format ignorieren und den numerischen Inhalt überprüfen:

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

Dies ist eine sehr lockere Option, und ich ziehe es vor, sie so zu halten. Meistens verwende ich sie in Registrierungsformularen, in denen die Benutzer ihre Telefonnummer hinzufügen müssen. Normalerweise haben Benutzer Probleme mit Formularen, die strenge Formatierungsregeln durchsetzen. Ich bevorzuge, dass Benutzer die Nummer und das Format in der Anzeige eingeben oder bevor sie in der Datenbank gespeichert werden. http://regexr.com/3c53v

Der folgende REGEX validiert eines dieser Formate:

(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}$/

Ich würde vorschlagen, etwas klareres zu verwenden (insbesondere zu überlegen, wer den Code pflegen muss) ... was ist mit:

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

Wo wird der reguläre Ausdruck aus einer klaren Vorlage erstellt? Das Hinzufügen eines neuen wäre dann ein Kinderspiel und möglicherweise könnte sogar der Kunde selbst dies auf einer "Options" -Seite tun.

Wobei str eines dieser Formulare sein könnte: 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");

Probieren Sie dieses aus - es beinhaltet auch die Validierung für internationale Formate.

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

Dieser reguläre Ausdruck überprüft das folgende Format:

• (541) 754-3010 Inland
• + 1-541-754-3010 International
• 1-541-754-3010 In den USA gewählt
• 001-541-754-3010 Aus Deutschland gewählt
• 191 541 754 3010 Aus Frankreich gewählt

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

Dieser Beitrag ist zwar alt, möchte aber meinen Beitrag hinterlassen. Diese werden akzeptiert: 5555555555 555-555-5555 (555)555-5555 1 (555) 555-5555 1 555 555 5555 1 555-555-5555 1 (555) 555-5555

diese werden nicht akzeptiert:

555-5555 -> um diese Verwendung zu akzeptieren: ^\+?1?\s*?\(?(\d{3})?(?:\)|[-|\s])?\s*?\d{3}[-|\s]?\d{4}$

5555555 -> um diese Verwendung zu akzeptieren: ^\+?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

Dies ist der Code, den ich verwendet habe:

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

Das wird funktionieren:

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

Das ?Zeichen bedeutet, dass die vorhergehende Gruppe null oder einmal übereinstimmen sollte. Die Gruppe entspricht (-|\s)entweder einem -oder einem |Zeichen. Durch Hinzufügen ?nach dem zweiten Auftreten dieser Gruppe in Ihrem regulären Ausdruck können Sie eine Folge von 10 aufeinander folgenden Ziffern abgleichen.

wirklich einfach

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

Alle Antworten sind großartig, aber hier ist eine, die ich für etwas umfassender halte ...

Dies ist für die Verwendung von Javascript-Übereinstimmungen mit einer einzelnen Zahl in einer einzelnen Zeile geschrieben:

^(?!.*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})$

Wenn Sie an Wortgrenzen übereinstimmen möchten, ändern Sie einfach ^ und $ in \ b

Ich freue mich über Vorschläge, Korrekturen oder Kritik an dieser Lösung. Soweit ich das beurteilen kann, entspricht dies dem NANP-Format (für USA-Nummern - ich habe andere nordamerikanische Länder bei der Erstellung nicht validiert), vermeidet 911-Fehler (kann nicht in der Vorwahl oder der Vorwahl enthalten sein), beseitigt nur die 555 Nummern, die tatsächlich ungültig sind (Regionalcode 555 gefolgt von 01xx, wobei x = eine beliebige Nummer).

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

Das ?Zeichen bedeutet, dass die vorhergehende Gruppe null oder einmal übereinstimmen sollte. Die Gruppe entspricht (-|\s)entweder einem -oder einem |Zeichen.

Ich muss zustimmen, dass die Validierung von Telefonnummern eine schwierige Aufgabe ist. Für dieses spezielle Problem würde ich den regulären Ausdruck von ändern

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

zu

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

als einziges weiteres Element, das unnötig wird, ist der letzte Bindestrich / Leerzeichen.

Wenn Sie ein Eingabe-Tag verwenden, hilft Ihnen dieser Code. Ich schreibe diesen Code selbst und denke, dass dies eine sehr gute Möglichkeit ist, Eingaben zu verwenden. Sie können es jedoch mit Ihrem Format ändern. Es hilft dem Benutzer, sein Format auf dem Eingabe-Tag zu korrigieren.

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

Ich wollte nur eine Lösung speziell für die Auswahl nicht lokaler Telefonnummern (800 und 900 Typen) hinzufügen.

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

Diese Registrierung eignet sich für internationale Telefonnummern und verschiedene Formate von Mobiltelefonnummern.

Hier ist der reguläre Ausdruck: / ^ (+ {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} $ /

Hier ist die JavaScript-Funktion

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

Dies validiert die folgenden Formate:

+44 07988-825 465 (mit einer beliebigen Kombination von Bindestrichen anstelle von Leerzeichen, außer dass nur ein Leerzeichen auf +44 folgen darf)

+44 (0) 7988-825 465 (mit einer beliebigen Kombination von Bindestrichen anstelle von Leerzeichen, außer dass kein Bindestrich direkt vor oder nach (0) vorhanden sein kann und das Leerzeichen vor oder nach (0) nicht vorhanden sein muss)

123 456-789 0123 (mit einer beliebigen Kombination von Bindestrichen anstelle der Leerzeichen)

123-123 123 (mit einer beliebigen Kombination von Bindestrichen anstelle der Leerzeichen)

123 123456 (Leerzeichen können durch einen Bindestrich ersetzt werden)

1234567890

Für alle Formate können keine doppelten Leerzeichen oder doppelten Bindestriche vorhanden sein.

Überprüfen Sie die Telefonnummer und geben Sie formatierte Daten zurück

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

Versuche dies

/ ^ (\ + {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

gültige Formate

• (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
• +7910 120 54 54
• 910 120 54 54
• 8 999 999 99 99

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

Diese Funktion hat bei uns gut funktioniert:

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

Einfacher regulärer Ausdruck: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g

Schauen Sie sich das Format an und hoffen Sie, dass es funktioniert:
444-555-1234
f: 246.555.8888
m: 1235554567

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

Dadurch wird jede Telefonnummer mit variablem Format überprüft:

\\(?\d{3}\\)? findet 3 Ziffern in Klammern oder nicht.

([\-\s\.])? findet eines dieser Trennzeichen oder nicht

\d{3} findet 3 Ziffern

\1verwendet das erste übereinstimmende Trennzeichen - dies stellt sicher, dass die Trennzeichen identisch sind. Daher wird (000) 999-5555 hier nicht validiert, da ein Leerzeichen und ein Strich-Trennzeichen vorhanden sind. Entfernen Sie einfach das "\ 1" und ersetzen Sie es durch das Trennzeichen-Untermuster (dies validiert auch nicht standardmäßige Formate). Sie sollten jedoch ohnehin Formathinweise für Benutzereingaben verwenden.

\d{4} findet 4 Ziffern

Validiert:

• (000) 999 5555
• (000) -999-5555
• (000) .999.5555
• (000) 999-5555
• (000) 9995555
• 000 999 5555
• 000-999-5555
• 000.999.5555
• 0009995555

Übrigens ist dies für JavaScript, um Escapezeichen zu verdoppeln.

Versuchen Sie diese js-Funktion. Gibt true zurück , wenn es passt und falsch , wenn es fehlschlägt Ref

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

Ignoriere einfach alles außer Ziffern.

Folgendes benutze ich:

// 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
}

Versuche dies

/^[\+]?\d{2,}?[(]?\d{2,}[)]?[-\s\.]?\d{2,}?[-\s\.]?\d{2,}[-\s\.]?\d{0,9}$/im

gültige Formate:

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