Validador de Regex para Números de Teléfono en Go

¿Qué es el Regex de Números de Teléfono en Go?

En Go (Golang), las expresiones regulares se gestionan mediante la librería estándar regexp. Validar números de teléfono implica verificar estructuras específicas como:

• Códigos de país (por ejemplo, +91, +1)

• Códigos de área

• Separadores opcionales como guiones, espacios o paréntesis

• Longitudes de número variables según el país o región

El regex de números de teléfono es especialmente útil en:

• Validaciones de formularios durante registros de usuario

• Verificaciones en backend para APIs o bases de datos

• Sistemas de comunicación SMS/llamadas

• Software de telecomunicaciones y aplicaciones móviles

Características y Construcciones Principales (Regex en Go)

Metacaracteres

• .: Coincide con cualquier carácter excepto salto de línea. Ejemplo: /.23/ coincide con "a23", "x23"

• ^: Ancla al inicio de la cadena. Ejemplo: /^+91/ coincide con "+91xxxxx..."

• $: Ancla al final de la cadena. Ejemplo: /123$/ coincide con cadenas que terminan en "123"

• |: Actúa como OR. Ejemplo: /fijo|móvil/ coincide con cualquiera de las dos palabras

Clases de Caracteres

• [0-9]: Coincide con cualquier dígito del 0 al 9

• [^0-9]: Coincide con cualquier carácter que no sea dígito

• [a-zA-Z]: Coincide con cualquier letra (minúscula o mayúscula)

Clases Predefinidas

• \d: Coincide con un dígito. Equivalente a [0-9]

• \D: Coincide con un carácter que no es dígito

• \s: Coincide con un espacio en blanco

• \S: Coincide con cualquier carácter que no sea espacio en blanco

Cuantificadores

• *: Coincide con cero o más ocurrencias

• +: Coincide con una o más ocurrencias

• ?: Coincide con cero o una (opcional)

• {n}: Coincide exactamente n veces

• {n,}: Coincide al menos n veces

• {n,m}: Coincide entre n y m veces

Limitar el Número de Coincidencias en Regex

Si desea que su búsqueda con expresiones regulares en Go devuelva solo un número limitado de coincidencias, pase un entero no negativo como segundo argumento a funciones como FindAllString o FindAllStringSubmatch. Este número determina cuántas coincidencias se devolverán desde el inicio de la cadena. Por ejemplo, usar FindAllString("peach punch pinch", 2) devolverá solo las primeras dos coincidencias en lugar de todas.

Este enfoque es útil cuando solo necesita un subconjunto de coincidencias, como obtener los primeros números de teléfono de un bloque de texto extenso.

Ejemplo de Patrón Regex para Números de Teléfono

A continuación, un patrón regex común para validar números de teléfono internacionales:

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

Este patrón admite:

• Códigos de país como +91, +44, +1

• Separadores opcionales como guiones, puntos y espacios

• Paréntesis para códigos de área

Métodos Comunes de los Objetos regexp en Go

Una vez compilada una expresión regular con el paquete regexp de Go, dispone de varios métodos útiles para coincidir, buscar, extraer y transformar cadenas:

• MatchString / Match: Verifica rápidamente si el patrón coincide con parte o toda una cadena. Ideal para validaciones básicas.

• FindString / Find: Devuelve la primera subcadena que coincide con el patrón.

• FindStringIndex / FindIndex: Devuelve las posiciones de inicio y fin de la primera coincidencia.

• FindStringSubmatch / FindSubmatch: Obtiene no solo la coincidencia principal, sino también los grupos de captura del patrón.

• FindStringSubmatchIndex / FindSubmatchIndex: Similar al anterior, pero devuelve índices de todos los grupos capturados.

• Variantes All (FindAllString, FindAllStringSubmatch, etc.): Escanean toda la entrada y devuelven todas las coincidencias o subcoincidencias. Puede limitar el número de resultados pasando un contador.

• ReplaceAllString / ReplaceAll: Reemplaza eficientemente todas las subcadenas coincidentes con otro valor.

• ReplaceAllFunc: Aplica una función a cada coincidencia para transformar el texto de forma dinámica.

Al almacenar patrones regex en variables globales, use MustCompile en lugar de Compile para garantizar que el patrón sea válido al inicio del programa.

Ejemplos de Código en Go

Ejemplo 1: Validación Básica de Teléfono

package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile(^\+?[0-9]{10,15}$)
phone := "+14155552671"
fmt.Println("Valid Phone:", pattern.MatchString(phone))
}

Pruebe patrones similares en el Go Regex Tester

Ejemplo 2: Números de Teléfono con Separadores

package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile(^$begin:math:text$?\\d{3}$end:math:text$?[-.\s]?\d{3}[-.\s]?\d{4}$)
phone := "(415) 555-2671"
fmt.Println("Valid Format:", pattern.MatchString(phone))
}

Genere números reales con el Generador de Números de Teléfono

Ejemplo 3: Prueba de Campo de Formulario con Código de Área

package main
import (
"fmt"
"regexp"
)
func main() {
input := "+91-9876543210"
regex := regexp.MustCompile(^\+91[-\s]?[6-9]\d{9}$)
fmt.Println("Indian Mobile Number Valid:", regex.MatchString(input))
}

Combínelo con el Generador de Direcciones para datos de usuario de prueba completos.

Obtener Índices de Coincidencias y Subcoincidencias en Go

Para recuperar las posiciones exactas de inicio y fin de coincidencias y subcoincidencias dentro de una cadena, use el método FindStringSubmatchIndex. Por ejemplo:

fmt.Println(r.FindStringSubmatchIndex("peach punch"))

Esta llamada devuelve un segmento de enteros que indica los índices de bytes para la coincidencia completa y cada grupo de captura, de forma similar al método span() de Python.

Encontrar la Primera Coincidencia en una Cadena

Para obtener la primera subcadena que coincida con su expresión regular, use el método FindString() de Go:

pattern := regexp.MustCompile([a-zA-Z]+)
result := pattern.FindString("peach punch")
// result will be "peach"

Si no hay coincidencia, devuelve una cadena vacía.

Reemplazar Subcadenas con Expresiones Regulares en Go

Reemplazo Básico con ReplaceAllString

package main
import (
"fmt"
"regexp"
)
func main() {
r := regexp.MustCompile(peach)
result := r.ReplaceAllString("a peach", "")
fmt.Println(result) // Output: a
}

Avanzado: Reemplazo con Funciones Personalizadas

package main
import (
"bytes"
"fmt"
"regexp"
)
func main() {
r := regexp.MustCompile([a-z]+)
text := []byte("a peach")
result := r.ReplaceAllFunc(text, bytes.ToUpper)
fmt.Println(string(result)) // Output: A PEACH
}

Trabajar con Byte Slices en Regex de Go

En Go, los métodos de regex no solo operan sobre cadenas. Si sus datos están almacenados como byte slices ([]byte), puede usar las mismas expresiones regulares compiladas llamando a métodos como Match() en lugar de MatchString().

Consejos Avanzados

• Siempre use regexp.MustCompile() para patrones estáticos y evitar errores en tiempo de ejecución.

• Use FindStringSubmatch() si desea extraer partes como códigos de área o extensiones.

• Evite expresiones demasiado codiciosas como .*, use cuantificadores como {10,15} para mayor precisión.

• Valide con datos de prueba reales de herramientas como el Generador de Números de Teléfono o el Generador de Nombre de Usuario.

• Use el prefijo (?i) para coincidencias sin distinción entre mayúsculas y minúsculas cuando sea necesario.

Combine con Estas Herramientas

• Generador de Números de Teléfono: Genere números de teléfono ficticios para validación.

• Generador de Email: Combínelo con email para formularios de registro.

• Generador de Nombre de Usuario: Úselo en la creación de perfiles de usuario.

• Generador de Direcciones: Simule formularios de contacto completos.

• Generador de Contraseñas: Para pruebas de flujo completo de registro de usuario.

• Generador de UUID: Combínelo para IDs de dispositivos o usuarios.

Casos de Uso

• Validación de formularios de registro

• Verificación móvil en e-commerce

• Pruebas de API de telecomunicaciones

• Generación de datos ficticios para equipos de QA

• Migración y normalización de datos

Regex para Otros Lenguajes

• JavaScript: Use el JavaScript Regex Tester

• Java: Pruebe en el Java Regex Tester

• Python: Pruebe en el Python Regex Tester