Expresiones regulares Java - Validar número de teléfono

En este breve artículo, veremos cómo validar un número de teléfono en Java, utilizando el paquete regex y varias expresiones regulares.

Las Expresiones Regulares (RegEx) son una herramienta poderosa y nos ayudan a igualar patrones de manera flexible, dinámica y eficiente, así como a realizar operaciones en base a los resultados.

En este tutorial, veremos cómo validar un número de teléfono en Java, usando expresiones regulares (RegEx).

If you'd like to read more about Regular Expressions and the regex package, read out Guía de expresiones regulares en Java!

Validación de números de teléfono en Java con RegEx

Los números de teléfono no son fáciles de validar y son notoriamente flexibles. Diferentes países tienen diferentes formatos, y algunos países incluso usan múltiples formatos y códigos de país.

Para validar un número de teléfono con expresiones regulares, tendrá que hacer un par de afirmaciones que generalicen bien a los números de teléfono, a menos que desee escribir muchas expresiones diferentes y validarlas a través de una lista de ellas.

Estas afirmaciones dependerán de su proyecto, su localización y los países a los que desea aplicarlo, pero tenga en cuenta que con un proyecto internacional, es posible que deba ser flexible con las restricciones para no permitir que un número de teléfono válido pase. al sistema

Para la validación estándar de números de teléfono de EE. UU., podemos usar la expresión larga y bastante robusta de:

1
^(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}$

Los 4 grupos de la expresión corresponden al código de país, número de área, número de abonado y extensión. Las expresiones entre los grupos están ahí para manejar una amplia variedad de formatos diferentes que puede ver:

1
2
3
123-456-7890
(123) 456-7890
etc...

También podría construir una expresión diferente imponiendo un conjunto de reglas para los grupos (según el país) y los formatos. puede esperar entrar.

Técnicamente, podría ir tan simple como verificar si hay 10 números en la cadena (12 si también cuenta el código de país), y debería poder validar algunos de los números de teléfono, pero tal simplicidad requeriría validación adicional ya sea en el front-end o la capacidad de adaptarse si un número de teléfono aceptado no es realmente válido:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
Pattern simplePattern = Pattern.compile("^\\+\\d{10,12}$");
Pattern robustPattern = Pattern.compile("^(\\+\\d{1,2}\\s)?\\(?\\d{3}\\)?[\\s.-]?\\d{3}[\\s.-]?\\d{4}$");

String phoneNumber = "+12 345 678 9012";

Matcher simpleMatcher = simplePattern.matcher(phoneNumber);
Matcher robustMatcher = robustPattern.matcher(phoneNumber);

if (simpleMatcher.matches()) {
    System.out.println(String.format("Simple Pattern matched for string: %s", phoneNumber));
}
if(robustMatcher.matches()) {
    System.out.println(String.format("Robust Pattern matched for string: %s", phoneNumber));
}

El primer comparador, aquí, ante todo tendrá problemas con los espacios en blanco presentes en la cadena, y coincidiría de lo contrario. Sin embargo, el patrón robusto no tiene ningún problema con esto:

1
Robust Pattern matched for string: +12 345 678 9012

El comparador robusto aquí podría coincidir con varios formatos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
Pattern robustPattern = Pattern.compile("^(\\+\\d{1,2}\\s)?\\(?\\d{3}\\)?[\\s.-]?\\d{3}[\\s.-]?\\d{4}$");

List<String> phoneNumbers = List.of(
        "+12 345 678 9012",
        "+123456789012",
        "345.678.9012",
        "345 678 9012"
);

for (String number : phoneNumbers) {
    Matcher matcher = robustPattern.matcher(number);
    if(matcher.matches()) {
        System.out.println(String.format("Robust Pattern matched for string: %s", number));
    }
}

Esto daría como resultado:

1
2
3
Robust Pattern matched for string: +12 345 678 9012
Robust Pattern matched for string: 345.678.9012
Robust Pattern matched for string: 345 678 9012

Combinación de varias expresiones regulares

Las expresiones regulares tienden a volverse desordenadas y largas. En cierto punto, se desordenan lo suficiente como para que no puedas cambiarlos o interpretarlos fácilmente.

En lugar de tener una Expresión regular única, universal y robusta que abarque todos los casos extremos, países, etc., puede optar por usar varios patrones diferentes que cubran razonablemente los números de teléfono entrantes. Para simplificar las cosas, puede encadenar estos expresiones a través del operador |, para verificar si el número de teléfono coincide con cualquiera de los patrones:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Pattern robustPattern = Pattern
        .compile(
                // Robust expression from before
                "^(\\+\\d{1,2}\\s)?\\(?\\d{3}\\)?[\\s.-]?\\d{3}[\\s.-]?\\d{4}$"
                // Area code, within or without parentheses,
                // followed by groups of 3-4 numbers with or without hyphens
                + "| ((\\(\\d{3}\\) ?)|(\\d{3}-))?\\d{3}-\\d{4}"
                // (+) followed by 10-12 numbers
                + "|^\\+\\d{10,12}"
);

List<String> phoneNumbers = List.of(
        "+12 345 678 9012",
        "+123456789012",
        "345.678.9012",
        "345 678 9012"
);

for (String number : phoneNumbers) {
    Matcher matcher = robustPattern.matcher(number);
    if(matcher.matches()) {
        System.out.println(String.format("Pattern matched for string: %s", number));
    }
}

Esto resulta en:

1
2
3
4
Pattern matched for string: +12 345 678 9012
Pattern matched for string: +123456789012
Pattern matched for string: 345.678.9012
Pattern matched for string: 345 678 9012

Conclusión

Los números de teléfono son complicados, eso es un hecho. Las expresiones regulares son una herramienta realmente versátil y poderosa y pueden abordar el problema de la validación de números de teléfono, pero hay que admitir que es un proceso complicado.

Ciertos países siguen diferentes estándares, mientras que otros adoptan y usan múltiples formatos al mismo tiempo, lo que dificulta escribir una expresión de propósito general para que coincida con los números de teléfono universalmente.

En este breve artículo, hemos analizado cómo relacionar números de teléfono con expresiones regulares en Java, con algunas expresiones diferentes.