Validar número de teléfono con JavaScript

Encontré este código en algún sitio web y funciona perfectamente. Valida que el número de teléfono esté en uno de estos formatos:
(123) 456-7890 o 123-456-7890

El problema es que mi cliente (no sé por qué, tal vez cosas del cliente) quiere agregar otro formato, los diez números consecutivamente, algo como esto: 1234567890 .

Estoy usando esta expresión regular,

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

¿Cómo puedo agregar que también valida el otro formato? No soy bueno con las expresiones regulares.

En primer lugar, su validador de formato obviamente solo es apropiado para números NANP (código de país +1). ¿Su aplicación será utilizada por alguien con un número de teléfono de fuera de América del Norte? Si es así, no desea evitar que esas personas ingresen un número [internacional] perfectamente válido.

En segundo lugar, su validación es incorrecta. Los números NANP toman la forma NXX NXX XXXXdonde Nes un dígito 2-9 y Xes un dígito 0-9. Además, los códigos de área y los intercambios pueden no tomar la forma N11(terminar con dos) para evitar confusiones con servicios especiales, excepto los números en un código de área no geográfico (800, 888, 877, 866, 855, 900) pueden tener un N11intercambio.

Por lo tanto, su expresión regular pasará el número (123) 123 4566 aunque no sea un número de teléfono válido. Puede arreglar eso reemplazando \d{3}con [2-9]{1}\d{2}.

Finalmente, tengo la sensación de que está validando la entrada del usuario en un navegador web. Recuerde que la validación del lado del cliente es solo una conveniencia que usted brinda al usuario ; aún necesita validar toda la entrada (nuevamente) en el servidor.

TL; DR no utiliza una expresión regular para validar datos complejos del mundo real como números de teléfono o URL . Utiliza una biblioteca especializada .

Mi expresión regular de elección es:

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

Si está buscando 10 y solo 10 dígitos, ignore todo menos los dígitos.

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

Lo que haría es ignorar el formato y validar el contenido 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

Esta es una opción muy flexible y prefiero mantenerla de esta manera, principalmente la uso en formularios de registro donde los usuarios necesitan agregar su número de teléfono. Por lo general, los usuarios tienen problemas con los formularios que aplican reglas de formato estrictas, prefiero que el usuario complete el número y el formato en la pantalla o antes de guardarlo en la base de datos. http://regexr.com/3c53v

El siguiente REGEX validará cualquiera de estos 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}$/

Sugeriría usar algo más claro (especialmente pensando en quién tendrá que mantener el código) ... ¿qué pasa con:

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

donde la expresión regular se construye a partir de una plantilla clara? Agregar uno nuevo sería obvio e incluso el propio cliente podría hacerlo en una página de "opciones".

Donde str podría ser cualquiera de estos 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");

Pruebe este: también incluye validación para formatos internacionales.

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

Esta expresión regular valida el siguiente formato:

• (541) 754-3010 Doméstico
• + 1-541-754-3010 Internacional
• 1-541-754-3010 Marcado en los EE. UU.
• 001-541-754-3010 Marcado desde Alemania
• 191 541 754 3010 Marcado desde Francia

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

Aunque este post es antiguo pero quiero dejar mi contribución. estos son aceptados: 5555555555 555-555-5555 (555)555-5555 1 (555) 555-5555 1 555 555 5555 1 555-555-5555 1 (555) 555-5555

estos no son aceptados:

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

5555555 -> para aceptar este 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 es el código que utilicé:

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

Esto funcionará:

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

El ?carácter significa que el grupo anterior debe coincidir cero o una vez. El grupo (-|\s)coincidirá con uno -o un |personaje. Agregar ?después de la segunda aparición de este grupo en su expresión regular le permite hacer coincidir una secuencia de 10 dígitos consecutivos.

realmente simple

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

Las respuestas de todos son geniales, pero aquí hay una que creo que es un poco más completa ...

Esto está escrito para el uso de coincidencia de JavaScript de un solo número en una sola línea:

^(?!.*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 desea hacer coincidir los límites de palabras, simplemente cambie ^ y $ a \ b

Agradezco cualquier sugerencia, corrección o crítica de esta solución. Por lo que puedo decir, esto coincide con el formato NANP (para números de EE. UU. - No validé otros países de América del Norte al crear esto), evita cualquier error 911 (no puede estar en el código de área o código de región), elimina solo aquellos 555 números que en realidad no son válidos (código de región de 555 seguido de 01xx donde x = cualquier número).

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

El ?carácter significa que el grupo anterior debe coincidir cero o una vez. El grupo (-|\s)coincidirá con uno -o un |personaje.

Tengo que aceptar que validar los números de teléfono es una tarea difícil. En cuanto a este problema específico, cambiaría la expresión regular de

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

a

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

Como el único elemento más que se vuelve innecesario es el último guión / espacio.

Si usa una etiqueta de entrada, este código lo ayudará. Escribo este código por mí mismo y creo que esta es una muy buena manera de usarlo en la entrada. pero puedes cambiarlo usando tu formato. Ayudará al usuario a corregir su formato en la etiqueta 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;
}

Solo quería agregar una solución específica para seleccionar números de teléfono no locales (tipos 800 y 900).

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

Este registro es adecuado para números de teléfono internacionales y múltiples formatos de números de teléfonos móviles.

Aquí está la expresión 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} $ /

Aquí está la función de 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;
    }
}

Esto valida los siguientes formatos:

+44 07988-825 465 (con cualquier combinación de guiones en lugar de espacio excepto que solo un espacio debe seguir al +44)

+44 (0) 7988-825 465 (con cualquier combinación de guiones en lugar de espacios, excepto que no puede existir un guión directamente antes o después del (0) y el espacio antes o después del (0) no necesita existir)

123 456-789 0123 (con cualquier combinación de guiones en lugar de los espacios)

123-123 123 (con cualquier combinación de guiones en lugar de los espacios)

123 123456 (El espacio se puede reemplazar con un guión)

1234567890

No pueden existir espacios dobles ni guiones dobles para todos los formatos.

Validar número de teléfono + devolver datos formateados

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

prueba esto

/ ^ (\ + {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 función nos funcionó bien:

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

Expresión regular simple: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g

Echa un vistazo al formato, espero que funcione:
444-555-1234
f: 246.555.8888
m: 1235554567

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

Esto validará cualquier número de teléfono de formato variable:

\\(?\d{3}\\)? encuentra 3 dígitos encerrados entre paréntesis o no.

([\-\s\.])? encuentra cualquiera de estos caracteres separadores o no

\d{3} encuentra 3 dígitos

\1utiliza el primer separador coincidente: esto garantiza que los separadores sean iguales. Entonces (000) 999-5555 no se validará aquí porque hay un espacio y un separador de guiones, así que simplemente elimine "\ 1" y reemplácelo con el subpatrón separador (hacerlo también validará formatos no estándar). Sin embargo, debería estar formateando sugerencias para la entrada del usuario de todos modos.

\d{4} encuentra 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

Por cierto, esto es para JavaScript, por lo tanto, para dobles escapes.

Prueba esta función js. Devuelve verdadero si coincide y falso si falla Ref.

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

Solo ignora todo menos los dígitos.

Esto es lo que 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
}

prueba esto

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