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 comillas invertidas (`) para crear strings, las barras invertidas (\) no tienen ningún significado especial y no marcan el comienzo 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 este motivo, es recomendable usar comillas invertidas para crear expresiones regulares, porque así no necesitamos escapar las barras invertidas:

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

Compilación de patrones: el tipo RegExp

Para usar una expresión regular, primero debemos compilar el patrón de la expresión regular como string. Compilar aquí significa tomar ese patrón de string 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, 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 de string en un regexp.Regexp usando la función regexp.Compile. Esta función devuelve nil y un error si la compilación falla:

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 cómoda a Compile:

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

Al usar esta función, no es necesario gestionar 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 coincidente. 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 toda la expresión.
• Si String está presente, el argumento es un string; en caso contrario, es un slice de bytes; los valores devueltos se ajustan según corresponda.
• Si Submatch está presente, el valor devuelto es un 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 por 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 obtener detalles sobre estas y otras funciones.

Ejemplos de MatchString

El método MatchString indica 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 un 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 devuelto de 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 por 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 un slice de los substrings entre esas coincidencias de la expresión. El recuento n determina el número máximo 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 garantiza ejecutarse en un tiempo lineal con el tamaño de la entrada.

Advertencia

El paquete regexp implementa las expresiones regulares RE2 (excepto \C). La sintaxis es en gran medida compatible con PCRE («expresión regular compatible con Perl»), pero hay algunas diferencias. Consulta la «sección de advertencia» en este artículo para obtener más detalles.