Convalida il numero di telefono con JavaScript

Ho trovato questo codice in alcuni siti Web e funziona perfettamente. Convalida che il numero di telefono è in uno di questi formati:
(123) 456-7890 o 123-456-7890

Il problema è che il mio cliente (non so perché, forse roba del cliente) vuole aggiungere un altro formato, i dieci numeri consecutivi, qualcosa del genere: 1234567890 .

Sto usando questa espressione regolare,

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

Come posso aggiungere che convalida anche un altro formato? Non sono bravo con le espressioni regolari.

Prima di tutto, il tuo validatore di formato è ovviamente appropriato solo per i numeri NANP (prefisso nazionale +1). L'applicazione verrà utilizzata da qualcuno con un numero di telefono al di fuori del Nord America? In tal caso, non vuoi impedire a queste persone di inserire un numero [internazionale] perfettamente valido.

In secondo luogo, la convalida non è corretta. I numeri NANP assumono la forma in NXX NXX XXXXcui Nè una cifra 2-9 ed Xè una cifra 0-9. Inoltre, i prefissi e gli scambi non possono assumere la forma N11(terminano con due) per evitare confusione con servizi speciali ad eccezione dei numeri in un prefisso non geografico (800, 888, 877, 866, 855, 900) possono avere uno N11scambio.

Quindi, il tuo regex passerà il numero (123) 123 4566 anche se non è un numero di telefono valido. È possibile risolvere il problema sostituendolo \d{3}con [2-9]{1}\d{2}.

Infine, ho la sensazione che stai convalidando l'input dell'utente in un browser web. Ricorda che la convalida lato client è solo una comodità che fornisci all'utente ; è ancora necessario convalidare (di nuovo) tutti gli input sul server.

TL; DR non usano un'espressione regolare per convalidare dati complessi del mondo reale come numeri di telefono o URL . Utilizzare una biblioteca specializzata .

La mia regex di scelta è:

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

Formati validi:

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

Se stai cercando 10 e solo 10 cifre, ignora tutto tranne le cifre-

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

Quello che vorrei fare è ignorare il formato e convalidare il contenuto numerico:

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

Questa è un'opzione molto diffusa e preferisco mantenerla in questo modo, principalmente la utilizzo in moduli di registrazione in cui gli utenti devono aggiungere il proprio numero di telefono. Di solito gli utenti hanno problemi con i moduli che applicano regole di formattazione rigorose, preferisco che l'utente inserisca il numero e il formato nel display o prima di salvarlo nel database. http://regexr.com/3c53v

Il seguente REGEX convaliderà uno di questi formati:

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

Suggerirei di usare qualcosa di più chiaro (soprattutto pensando a chi dovrà mantenere il codice) ... che dire di:

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

dove regexp è costruito da un modello chiaro? Aggiungerne uno nuovo sarebbe un gioco da ragazzi e potrebbe anche essere il cliente stesso a poterlo fare in una pagina "opzioni".

Dove str potrebbe essere uno di questi formati: 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");

Prova questo: include anche la convalida per i formati internazionali.

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

Questa regex convalida il seguente formato:

• (541) 754-3010 Domestico
• + 1-541-754-3010 Internazionale
• 1-541-754-3010 Composto negli Stati Uniti
• 001-541-754-3010 composto dalla Germania
• 191 541 754 3010 composto dalla Francia

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

Anche se questo post è vecchio ma voglio lasciare il mio contributo. questi sono accettati: 5555555555 555-555-5555 (555)555-5555 1 (555) 555-5555 1 555 555 5555 1 555-555-5555 1 (555) 555-5555

questi non sono accettati:

555-5555 -> per accettare questo uso: ^\+?1?\s*?\(?(\d{3})?(?:\)|[-|\s])?\s*?\d{3}[-|\s]?\d{4}$

5555555 -> per accettare questo uso: ^\+?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

questo è il codice che ho usato:

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

Questo funzionerà:

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

Il ?carattere indica che il gruppo precedente deve essere associato a zero o una volta. Il gruppo (-|\s)abbinerà uno -o un |personaggio. L'aggiunta ?dopo la seconda occorrenza di questo gruppo nella tua regex ti consente di abbinare una sequenza di 10 cifre consecutive.

davvero semplice

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

Le risposte di tutti sono fantastiche, ma eccone una che penso sia un po 'più completa ...

Questo è scritto per l'uso della corrispondenza javascript di un singolo numero in una sola riga:

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

Se vuoi abbinare ai confini delle parole, cambia semplicemente ^ e $ in \ b

Accolgo con favore suggerimenti, correzioni o critiche a questa soluzione. Per quanto posso dire, questo corrisponde al formato NANP (per i numeri USA - non ho convalidato altri paesi del Nord America durante la creazione), evita errori 911 (non può essere nel prefisso o nel prefisso regionale), elimina solo quei 555 numeri che non sono effettivamente validi (codice regione di 555 seguito da 01xx dove x = qualsiasi numero).

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

Il ?carattere indica che il gruppo precedente deve essere associato a zero o una volta. Il gruppo (-|\s)abbinerà uno -o un |personaggio.

Sono d'accordo sul fatto che la convalida dei numeri di telefono sia un compito difficile. Per quanto riguarda questo problema specifico, cambierei la regex da

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

per

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

poiché l'unico altro elemento che diventa superfluo è l'ultimo trattino / spazio.

Se stai usando un tag di input di questo codice ti aiuterà. Scrivo questo codice da solo e penso che questo sia un ottimo modo per usare l'input. ma puoi cambiarlo usando il tuo formato. Aiuterà l'utente a correggere il proprio formato sul tag di 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;
}

Volevo solo aggiungere una soluzione specifica per la selezione di numeri di telefono non locali (tipi 800 e 900).

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

Questo registro è adatto per numeri di telefono internazionali e formati multipli di numeri di cellulare.

Ecco l'espressione regolare: / ^ (+ {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} $ /

Ecco la funzione 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;
    }
}

Ciò convalida i seguenti formati:

+44 07988-825 465 (con qualsiasi combinazione di trattini al posto dello spazio tranne per il fatto che solo uno spazio deve seguire il +44)

+44 (0) 7988-825 465 (con qualsiasi combinazione di trattini al posto degli spazi tranne per il fatto che nessun trattino può esistere direttamente prima o dopo lo (0) e non è necessario che lo spazio prima o dopo lo (0))

123 456-789 0123 (con qualsiasi combinazione di trattini al posto degli spazi)

123-123 123 (con qualsiasi combinazione di trattini al posto degli spazi)

123 123456 (lo spazio può essere sostituito con un trattino)

1234567890

Non esistono spazi doppi o trattini doppi per tutti i formati.

Convalida il numero di telefono + restituisci dati formattati

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

prova questo

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

formati validi

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

Questa funzione ha funzionato bene per noi:

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

Espressione regolare semplice: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g

Controlla il formato, spero che
funzioni : 444-555-1234
f: 246.555.8888
m: 1235554567

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

Ciò convaliderà qualsiasi numero di telefono di formato variabile:

\\(?\d{3}\\)? trova 3 cifre racchiuse tra parentesi o meno.

([\-\s\.])? trova uno di questi caratteri di separazione o no

\d{3} trova 3 cifre

\1usa il primo separatore abbinato - questo assicura che i separatori siano uguali. Pertanto (000) 999-5555 non verrà convalidato qui perché è presente un separatore di spazio e trattino, quindi è sufficiente rimuovere "\ 1" e sostituirlo con il sottotitolo del separatore (in tal modo verranno convalidati anche i formati non standard). Dovresti comunque essere comunque un suggerimento sul formato per l'input dell'utente.

\d{4} trova 4 cifre

Convalida:

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

A proposito questo è per JavaScript quindi per raddoppiare le fughe.

Prova questa funzione js. Restituisce vero se corrisponde e falso se fallisce Rif

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

Ignora tutto tranne le cifre.

Ecco cosa uso:

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

prova questo

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

formati validi:

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