Hoy te mostraré cómo trabajar con expresiones regulares en el lenguaje de programación Go, también conocido como Golang.

No te mostraré cómo usar las expresiones regulares, pues las mismas son independientes del lenguaje (aunque también tienen sabores) y son un tema aparte, así que solo te mostraré cómo trabajar con expresiones regulares en Go a través de regexp.

Comprobar si cadena coincide con expresión regular

Debido a que este es un post de introducción, vamos a ver algo sencillo: cómo saber si una cadena coincide con una expresión regular en Go. Para ello primero importamos a regexp:

import "regexp"

Luego compilamos la expresión regular:

expresionRegular := regexp.MustCompile("aquí_la_expresión_regular")

Y finalmente invocamos a Match convirtiendo al cadena a un arreglo de bytes:

coincide := expresionRegular.Match([]byte("cadena_para_probar))

El método Match devolverá true o false dependiendo de si la cadena coincide o no con la expresión regular.

Por cierto, ya que estamos aquí, te recomiendo un sitio en donde yo pruebo mis expresiones regulares: https://regex101.com/

Ejemplo de expresión regular en Go

Veamos un ejemplo. Vamos a comprobar (de manera simple, no lo uses en producción sin antes probarlo) si una cadena representa el subdominio de un dominio, o al dominio en sí.

Por ejemplo, para el dominio parzibyte.me, los subdominios como hola.parzibyte.me, ejemplos.parzibyte.me y todos los demás deberían pasar la prueba (agregando https:// o http:// al inicio). También parzibyte.me debería pasarlo.

Entonces la expresión regular queda así:

^https?:\/\/([\w-]+\.)?parzibyte\.me$

Recuerda que ^ marca el inicio de la cadena, y $ el final. El ? después de la s indica que la S de http es opcional (así puede ser http o https). Luego usamos \ para escapar las barras (esto también sirve para escapar los puntos).

Después, ([\w-]+\.)? indica que puede o no aparecer lo que está dentro de los paréntesis, y lo que está dentro quiere decir cualquier letra o número 1 o más veces, seguidas de un punto.

Probando expresión regular en Go con Match

Anteriormente expliqué la expresión regular. Ahora la probamos:

expresionRegular := regexp.MustCompile(`^https?:\/\/([\w-]+\.)?parzibyte\.me$`)
subdominioPrueba := "https://blog.parzibyte.me"
if expresionRegular.Match([]byte(subdominioPrueba)) {
  fmt.Println("Coincide")
} else {
  fmt.Println("NO coincide")
}

En este caso la cadena cumple la expresión regular. Como puedes ver, defino la expresión regular en la línea 1. Después hago el Match en la línea 3 e imprimo según el resultado.

Ejemplo completo

Además de probar la expresión regular en Go con una cadena, podemos hacerlo con un arreglo para probar más opciones. El código completo queda así:

package main

/*
 https://parzibyte.me/blog
*/import (
 "fmt"
 "regexp"
)

func main() {
 subdominios := [...]string{
  "https://ejemplo.parzibyte.me",
  "https://sublime-pos.parzibyte.me",
  "https://juegos.parzibyte.me",
  "https://admin.parzibyte.me",
  "https://hola.parzibyte.me",
  "http://hola.parzibyte.me",
  "http://www.parzibyte.me",
  "https://www.parzibyte.me",
  "https://hola.parzibyte.com",
  "acerca-de.parzibyte.me",
 }
 expresionRegular := regexp.MustCompile(`^https?:\/\/([\w-]+\.)?parzibyte\.me$`)
 subdominioPrueba := "https://blog.parzibyte.me"
 if expresionRegular.Match([]byte(subdominioPrueba)) {
  fmt.Println("Coincide")
 } else {
  fmt.Println("NO coincide")
 }
 for _, subdominio := range subdominios {
  coincide := expresionRegular.Match([]byte(subdominio))
  fmt.Printf("¿'%s' coincide? %t\n", subdominio, coincide)
 }
}

Recorremos el arreglo y vamos probando cada opción. Para el caso de los dos últimos elementos, no habrá coincidencia, pues uno no inicia con http ni con https, además de que otro termina en .com y no en .me

De este modo podemos trabajar con expresiones regulares en Golang. Aquí puedes leer más sobre Go en mi blog.