Expresiones regulares en

Acerca de Expresiones regulares

El paquete regexp ofrece soporte para expresiones regulares en Go.

Sintaxis

La sintaxis de las expresiones regulares aceptadas es la misma sintaxis general que usan Perl, Python y otros lenguajes.

Tanto los patrones de búsqueda como los textos de entrada se interpretan como UTF-8.

Cuando usas acentos graves (`) para crear strings, las barras invertidas (\) no tienen ningún significado especial y no marcan el inicio de caracteres especiales como tabulaciones \t o saltos de línea \n:

"\t\n" // regular string literal with 2 characters: a tab and a newline
`\t\n`// raw string literal with 4 characters: two backslashes, a 't', and an 'n'

Por esto, conviene usar acentos graves para crear expresiones regulares, porque así no necesitamos escapar las barras invertidas:

"\\" // string with a single backslash
`\\` // string with 2 backslashes

Compilar patrones - el tipo RegExp

Para usar una expresión regular, primero debemos compilar el patrón string. Compilar aquí significa tomar el patrón string de la expresión regular y convertirlo en una representación interna con la que es más fácil trabajar. Solo necesitamos compilar cada patrón una vez; después de eso podemos usar la versión compilada de la expresión regular muchas veces. El tipo regexp.Regexp representa una expresión regular compilada. Podemos compilar un patrón string en un regexp.Regexp usando la función regexp.Compile. Esta función devuelve nil y un error si la compilación falló:

re, err := regexp.Compile(`(a|b)+`)
fmt.Println(re, err) // => (a|b)+ <nil>
re, err = regexp.Compile(`a|b)+`)
fmt.Println(re, err) // => <nil> error parsing regexp: unexpected ): `a|b)+`

La función MustCompile es una alternativa conveniente a Compile:

re = regexp.MustCompile(`[a-z]+\d*`)

Al usar esta función, no hay necesidad de manejar un error.

Métodos de las expresiones regulares

Hay 16 métodos de Regexp que buscan coincidencias de una expresión regular e identifican el texto que coincide. Sus nombres coinciden con esta expresión regular:

Find(All)?(String)?(Submatch)?(Index)?

• Si All está presente, la rutina busca coincidencias sucesivas no superpuestas de las expresiones completas.
• Si String está presente, el argumento es un string; de lo contrario, es una slice de bytes; los valores de retorno se ajustan según corresponda.
• Si Submatch está presente, el valor de retorno es una slice que identifica las subcoincidencias sucesivas de la expresión.
• Si Index está presente, las coincidencias y subcoincidencias se identifican mediante pares de índices de bytes dentro del string de entrada.

También hay métodos para:

• reemplazar coincidencias de expresiones regulares con strings de reemplazo y
• dividir strings separados por expresiones regulares.

En total, el paquete regexp define más de 40 funciones y métodos. A continuación mostraremos el uso de algunos métodos. Consulta la documentación de la API para ver los detalles de estas y otras funciones.

Ejemplos de MatchString

El método MatchString informa si un string contiene alguna coincidencia de una expresión regular.

re = regexp.MustCompile(`[a-z]+\d*`)
b = re.MatchString("[a12]")       // => true
b = re.MatchString("12abc34(ef)") // => true
b = re.MatchString(" abc!")       // => true
b = re.MatchString("123 456")     // => false

Ejemplos de FindString

El método FindString devuelve un string que contiene el texto de la coincidencia más a la izquierda de la expresión regular.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.FindString("[a12]")       // => "a12"
s = re.FindString("12abc34(ef)") // => "abc34"
s = re.FindString(" abc!")       // => "abc"
s = re.FindString("123 456")     // => ""

Ejemplos de FindStringSubmatch

El método FindStringSubmatch devuelve una slice de strings que contiene el texto de la coincidencia más a la izquierda de la expresión regular y las coincidencias, si las hay, de sus subexpresiones. Esto se puede usar para identificar los strings que coinciden con grupos de captura. Un valor de retorno nil indica que no hay coincidencia.

re = regexp.MustCompile(`[a-z]+(\d*)`)
sl = re.FindStringSubmatch("[a12]")       // => []string{"a12","12"}
sl = re.FindStringSubmatch("12abc34(ef)") // => []string{"abc34","34"}
sl = re.FindStringSubmatch(" abc!")       // => []string{"abc",""}
sl = re.FindStringSubmatch("123 456")     // => <nil>

Ejemplos de ReplaceAllString

El método re.ReplaceAllString(src,repl) devuelve una copia de src, reemplazando las coincidencias de la expresión regular re con el string de reemplazo repl.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.ReplaceAllString("[a12]", "X")       // => "[X]"
s = re.ReplaceAllString("12abc34(ef)", "X") // => "12X(X)"
s = re.ReplaceAllString(" abc!", "X")       // => " X!"
s = re.ReplaceAllString("123 456", "X")     // => "123 456"

Ejemplos de Split

El método re.Split(s,n) divide un texto s en substrings separados por la expresión y devuelve una slice con los substrings entre esas coincidencias de la expresión. El conteo n determina la cantidad máxima de substrings que se devolverán. Si n<0, el método devuelve todos los substrings.

re = regexp.MustCompile(`[a-z]+\d*`)
sl = re.Split("[a12]", -1)      // => []string{"[","]"}
sl = re.Split("12abc34(ef)", 2) // => []string{"12","(ef)"}
sl = re.Split(" abc!", -1)      // => []string{" ","!"}
sl = re.Split("123 456", -1)    // => []string{"123 456"}

Rendimiento

La implementación de regexp que proporciona este paquete tiene garantizado ejecutarse en un tiempo lineal respecto al tamaño de la entrada.

Advertencia

El paquete regexp implementa expresiones regulares RE2 (excepto \C). La sintaxis es en gran medida compatible con PCRE ("Perl Compatible Regular Expression"), pero hay algunas diferencias. Consulta la "sección de advertencias" en este artículo para ver los detalles.