Validar número de telefone com JavaScript

Encontrei esse código em algum site e funciona perfeitamente.
Valida se o número de telefone está em um destes formatos: (123) 456-7890 ou 123-456-7890

O problema é que meu cliente (não sei por que, talvez coisas do cliente) deseja adicionar outro formato, os dez números consecutivos, algo como isto: 1234567890 .

Eu estou usando essa expressão regular,

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

Como posso acrescentar que também valida o outro formato? Eu não sou bom com expressões regulares.

Primeiro, seu validador de formato é obviamente apropriado apenas para números NANP (código do país +1). Seu aplicativo será usado por alguém com um número de telefone de fora da América do Norte? Nesse caso, você não deseja impedir que essas pessoas insiram um número [internacional] perfeitamente válido.

Em segundo lugar, sua validação está incorreta. Os números NANP assumem o formato NXX NXX XXXXonde Nestá um dígito 2-9 e Xé um dígito 0-9. Além disso, os códigos de área e trocas não podem assumir o formato N11(terminar com dois) para evitar confusão com serviços especiais, exceto os números em um código de área não geográfico (800, 888, 877, 866, 855, 900) podem ter uma N11troca.

Portanto, seu regex passará o número (123) 123 4566, mesmo que esse não seja um número de telefone válido. Você pode corrigir isso substituindo \d{3}por [2-9]{1}\d{2}.

Por fim, sinto que você está validando a entrada do usuário em um navegador da web. Lembre-se de que a validação do lado do cliente é apenas uma conveniência que você fornece ao usuário ; você ainda precisa validar todas as entradas (novamente) no servidor.

TL; DR não usa uma expressão regular para validar dados complexos do mundo real, como números de telefone ou URLs . Use uma biblioteca especializada .

Minha regex de escolha é:

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

Formatos válidos:

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

Se você estiver procurando por 10 e apenas 10 dígitos, ignore tudo, exceto os dígitos,

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

O que eu faria é ignorar o formato e validar o conteúdo numérico:

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

Essa é uma opção muito flexível e prefiro mantê-la dessa maneira, principalmente em formulários de registro em que os usuários precisam adicionar seu número de telefone. Geralmente, os usuários têm problemas com formulários que aplicam regras estritas de formatação. Prefiro que o usuário preencha o número e o formato no visor ou antes de salvá-lo no banco de dados. http://regexr.com/3c53v

O seguinte REGEX validará qualquer um destes formatos:

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

Eu sugeriria usar algo mais claro (especialmente pensando em quem terá que manter o código) ... o que dizer:

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

onde o regexp é construído a partir de um modelo claro? Adicionar um novo seria um acéfalo e talvez até o próprio cliente pudesse fazer isso em uma página de "opções".

Onde str pode estar em qualquer um destes formatos: 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");

Experimente este - inclui validação para formatos internacionais também.

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

Este regex valida o seguinte formato:

• (541) 754-3010 Doméstica
• + 1-541-754-3010 Internacional
• 1-541-754-3010 Discado nos EUA
• 001-541-754-3010 Discado da Alemanha
• 191 541 754 3010 Discado da França

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

Embora este post seja antigo, mas quero deixar minha contribuição. estes são aceitos: 5555555555 555-555-5555 (555)555-5555 1 (555) 555-5555 1 555 555 5555 1 555-555-5555 1 (555) 555-5555

estes não são aceitos:

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

5555555 -> para aceitar esse 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

este é o código que eu usei:

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

Isso funcionará:

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

O ?caractere significa que o grupo anterior deve corresponder a zero ou uma vez. O grupo (-|\s)corresponderá a um -ou a um |personagem. Adicionar ?após a segunda ocorrência deste grupo ao seu regex permite combinar uma sequência de 10 dígitos consecutivos.

realmente simples

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

As respostas de todos são ótimas, mas aqui está uma que eu acho que é um pouco mais abrangente ...

Isso foi escrito para o uso de correspondência javascript de um único número em uma única linha:

^(?!.*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 você deseja corresponder aos limites das palavras, basta alterar os ^ e $ para \ b

Congratulo-me com todas as sugestões, correções ou críticas a esta solução. Até onde eu sei, isso corresponde ao formato NANP (para números dos EUA - eu não validei outros países da América do Norte ao criar isso), evita erros 911 (não pode estar no código de área ou código de região), elimina apenas os números 555 que são realmente inválidos (código de região 555 seguido por 01xx onde x = qualquer número).

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

O ?caractere significa que o grupo anterior deve corresponder a zero ou uma vez. O grupo (-|\s)corresponderá a um -ou a um |personagem.

Eu tenho que concordar que validar números de telefone é uma tarefa difícil. Quanto a esse problema específico, eu alteraria o regex de

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

para

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

como o único mais elemento que se torna desnecessário é o último traço / espaço.

Se você estiver usando a tag de entrada, esse código o ajudará. Eu escrevo esse código sozinho e acho que essa é uma maneira muito boa de usar na entrada. mas você pode alterá-lo usando seu formato. Isso ajudará o usuário a corrigir seu formato na tag de entrada.

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

Só queria adicionar uma solução especificamente para selecionar números de telefone não locais (tipos 800 e 900).

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

Este registro é adequado para números de telefone internacionais e vários formatos de números de celular.

Aqui está a expressão regular: / ^ (+ {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} $ /

Aqui está a função 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;
    }
}

Isso valida os seguintes formatos:

+44 07988-825 465 (com qualquer combinação de hífens no lugar do espaço, exceto que apenas um espaço deve seguir o +44)

+44 (0) 7988-825 465 (com qualquer combinação de hífens no lugar de espaços, exceto que nenhum hífen pode existir diretamente antes ou depois do (0) e o espaço antes ou depois do (0) não precisa existir)

123 456-789 0123 (com qualquer combinação de hífens no lugar dos espaços)

123-123 123 (com qualquer combinação de hífens no lugar dos espaços)

123 123456 (O espaço pode ser substituído por um hífen)

1234567890

Não podem existir espaços duplos ou hífens duplos para todos os formatos.

Validar número de telefone + retornar dados formatados

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

tente isso

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

formatos válidos

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

Esta função funcionou bem para nós:

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

Expressão regular simples: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g

Confira o formato, espero que funcione:
444-555-1234
f: 246.555.8888
m: 1235554567

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

Isso validará qualquer número de telefone de formato variável:

\\(?\d{3}\\)? encontra 3 dígitos entre parênteses ou não.

([\-\s\.])? encontra algum desses caracteres separadores ou não

\d{3} encontra 3 dígitos

\1usa o primeiro separador correspondente - isso garante que os separadores sejam os mesmos. Portanto, (000) 999-5555 não será validado aqui porque existe um separador de espaço e traço; portanto, remova o "\ 1" e substitua pelo sub-padrão do separador (isso também validará formatos fora do padrão). No entanto, você deve, no entanto, sugerir o formato para a entrada do usuário.

\d{4} encontra 4 dígitos

Valida:

• (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 isto é para JavaScript, portanto, para escapa duas vezes.

Tente esta função js. Retorna TRUE se ele corresponde e false se ele falhar Ref

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

Apenas ignore tudo, menos dígitos.

Aqui está o que eu 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
}

tente isso

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

formatos válidos:

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