Potwierdź numer telefonu za pomocą JavaScript

Znalazłem ten kod na jakiejś stronie i działa idealnie. Sprawdza, czy numer telefonu ma jeden z następujących formatów:
(123) 456-7890 lub 123-456-7890

Problem polega na tym, że mój klient (nie wiem dlaczego, może rzeczy klienta) chce dodać inny format, dziesięć liczb kolejno, coś takiego: 1234567890 .

Używam tego wyrażenia regularnego,

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

Jak mogę dodać, że sprawdza również inny format? Nie radzę sobie z wyrażeniami regularnymi.

Po pierwsze, twój walidator formatu jest oczywiście odpowiedni tylko dla numerów NANP (kod kraju +1). Czy Twoja aplikacja będzie używana przez kogoś, kto ma numer telefonu spoza Ameryki Północnej? Jeśli tak, nie chcesz uniemożliwić tym osobom wprowadzenia całkowicie prawidłowego [międzynarodowego] numeru.

Po drugie, Twoja walidacja jest nieprawidłowa. Numery NANP mają postać, NXX NXX XXXXgdzie Njest cyfrą 2-9 i Xcyfrą 0-9. Ponadto numery kierunkowe i giełdy nie mogą mieć formy N11(kończyć się dwoma), aby uniknąć pomyłki z usługami specjalnymi, z wyjątkiem numerów w niegeograficznym numerze kierunkowym (800, 888, 877, 866, 855, 900) mogą mieć N11wymianę.

Tak więc Twoje wyrażenie regularne przekaże numer (123) 123 4566, mimo że nie jest to prawidłowy numer telefonu. Można to naprawić poprzez wymianę \d{3}z [2-9]{1}\d{2}.

Wreszcie mam wrażenie, że sprawdzasz poprawność danych wejściowych użytkownika w przeglądarce internetowej. Pamiętaj, że walidacja po stronie klienta to tylko wygoda, którą zapewniasz użytkownikowi ; nadal musisz zweryfikować wszystkie dane wejściowe (ponownie) na serwerze.

TL; DR nie używają wyrażeń regularnych do weryfikacji złożonych rzeczywistych danych, takich jak numery telefonów lub adresy URL . Skorzystaj ze specjalistycznej biblioteki .

Mój wybrany regex to:

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

Prawidłowe formaty:

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

Jeśli szukasz 10 i tylko 10 cyfr, zignoruj ​​wszystko oprócz cyfr

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

Zignorowałbym format i zweryfikował zawartość liczbową:

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

Jest to bardzo luźna opcja i wolę ją taką zachować, najczęściej używam jej w formularzach rejestracyjnych, gdzie użytkownicy muszą podać swój numer telefonu. Zwykle użytkownicy mają problemy z formularzami, które wymuszają ścisłe reguły formatowania, wolę, aby użytkownik wpisał numer i sformatował go na wyświetlaczu lub przed zapisaniem go w bazie danych. http://regexr.com/3c53v

Poniższy REGEX zweryfikuje każdy z tych formatów:

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

Sugerowałbym użycie czegoś jaśniejszego (zwłaszcza myśląc o tym, kto będzie musiał utrzymywać kod) ... a co z:

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

gdzie wyrażenie regularne jest zbudowane z przejrzystego szablonu? Dodanie nowego byłoby wtedy oczywiste, a nawet sam klient mógłby to zrobić na stronie „opcje”.

Gdzie str może być dowolnym z tych 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");

Wypróbuj ten - obejmuje również walidację dla formatów międzynarodowych.

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

To wyrażenie regularne weryfikuje następujący format:

• (541) 754-3010 Krajowy
• + 1-541-754-3010 międzynarodowy
• 1-541-754-3010 Wybierany w USA
• 001-541-754-3010 Wybierany z Niemiec
• 191 541 754 3010 Wywoływane z Francji

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

Chociaż ten post jest stary, ale chcę opuścić mój wkład. są akceptowane: 5555555555 555-555-5555 (555)555-5555 1 (555) 555-5555 1 555 555 5555 1 555-555-5555 1 (555) 555-5555

te nie są akceptowane:

555-5555 -> aby zaakceptować to użycie: ^\+?1?\s*?\(?(\d{3})?(?:\)|[-|\s])?\s*?\d{3}[-|\s]?\d{4}$

5555555 -> aby zaakceptować to użycie: ^\+?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 2757 622-7382 10 (757) 622 -7382 27576227382 (275) 76227382 2 (757) 6227382 2 (757) 622-7382 (555) 5 (55?) - 5555

to jest kod, którego użyłem:

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

To zadziała:

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

Te ?oznacza, że grupa znaków poprzedzających powinny być dopasowane zero lub jeden razy. Grupa (-|\s)dopasuje znak -lub |znak. Dodanie ?po drugim wystąpieniu tej grupy w Twoim wyrażeniu regularnym umożliwia dopasowanie sekwencji 10 kolejnych cyfr.

naprawdę proste

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

Odpowiedzi wszystkich są świetne, ale oto jedna, która moim zdaniem jest nieco bardziej wszechstronna ...

Jest to napisane w celu dopasowania javascript do użycia pojedynczej liczby w jednym wierszu:

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

Jeśli chcesz dopasować w granicach słowa, po prostu zmień ^ i $ na \ b

Z zadowoleniem przyjmuję wszelkie sugestie, poprawki lub krytykę tego rozwiązania. O ile wiem, jest to zgodne z formatem NANP (dla numerów w USA - nie sprawdzałem poprawności innych krajów Ameryki Północnej podczas tworzenia tego), pozwala uniknąć błędów 911 (nie może być w numerze kierunkowym lub kodzie regionu), eliminuje tylko te numery 555, które są rzeczywiście nieprawidłowe (kod regionu 555, po którym następuje 01xx, gdzie x = dowolna liczba).

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

Te ?oznacza, że grupa znaków poprzedzających powinny być dopasowane zero lub jeden razy. Grupa (-|\s)dopasuje znak -lub |znak.

Muszę się zgodzić, że weryfikacja numerów telefonów to trudne zadanie. Jeśli chodzi o ten konkretny problem, zmieniłbym wyrażenie regularne z

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

do

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

jako jedyny dodatkowy element, który staje się niepotrzebny, to ostatnia myślnik / spacja.

Jeśli używasz tagu wejściowego, ten kod ci pomoże. Piszę ten kod samodzielnie i myślę, że jest to bardzo dobry sposób na wykorzystanie danych wejściowych. ale możesz to zmienić za pomocą swojego formatu. Pomoże to użytkownikowi poprawić ich format na znaczniku wejściowym.

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

Chciałem tylko dodać rozwiązanie przeznaczone specjalnie do wybierania nielokalnych numerów telefonów (typy 800 i 900).

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

Ten rejestr jest odpowiedni dla międzynarodowych numerów telefonów i wielu formatów numerów komórkowych.

Oto wyrażenie regularne: / ^ (+ {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} $ /

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

Sprawdza to następujące formaty:

+44 07988-825 465 (z dowolną kombinacją myślników zamiast spacji, z wyjątkiem tego, że tylko spacja musi występować po +44)

+44 (0) 7988-825 465 (z dowolną kombinacją myślników zamiast spacji, z wyjątkiem tego, że żaden łącznik nie może istnieć bezpośrednio przed lub po (0), a spacja przed lub po (0) nie musi istnieć)

123 456-789 0123 (z dowolną kombinacją myślników zamiast spacji)

123-123 123 (z dowolną kombinacją myślników zamiast spacji)

123 123456 (spację można zastąpić łącznikiem)

1234567890

Dla wszystkich formatów nie mogą istnieć podwójne spacje ani łączniki.

Sprawdź poprawność numeru telefonu + zwróć sformatowane dane

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

Spróbuj tego

/ ^ (\ + {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,} $ / gm

prawidłowe formaty

• (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

Ta funkcja działała dla nas dobrze:

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

Proste wyrażenie regularne: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g

Sprawdź format, mam nadzieję, że
zadziała : 444-555-1234
f: 246.555.8888
m: 1235554567

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

Spowoduje to sprawdzenie dowolnego numeru telefonu o zmiennym formacie:

\\(?\d{3}\\)? znajduje 3 cyfry w nawiasach lub nie.

([\-\s\.])? znajduje dowolny z tych znaków separatora lub nie

\d{3} znajduje 3 cyfry

\1używa pierwszego dopasowanego separatora - zapewnia to, że separatory są takie same. Tak więc (000) 999-5555 nie będzie sprawdzać poprawności w tym miejscu, ponieważ istnieje separator spacji i myślnika, więc po prostu usuń „\ 1” i zastąp go pod-wzorcem separatora (spowoduje to również sprawdzenie poprawności niestandardowych formatów). Powinieneś jednak i tak podawać wskazówki dotyczące formatu przy wprowadzaniu danych przez użytkownika.

\d{4} znajduje 4 cyfry

Weryfikuje:

• (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, to jest dla JavaScript, stąd podwójne znaki ucieczki.

Wypróbuj tę funkcję js. Zwraca wartość true, jeśli pasuje, lub false, jeśli się nie powiedzie Ref

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

Po prostu ignoruj ​​wszystko oprócz cyfr.

Oto czego używam:

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

Spróbuj tego

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

prawidłowe formaty:

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