Análisis de archivos de registro

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 inicio de caracteres especiales como las tabulaciones \t o los 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 eso, conviene usar comillas invertidas para crear expresiones regulares, porque así no necesitas 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 de string. Compilar aquí significa tomar el patrón de 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 de 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*`)

Con esta función, no necesitas manejar ningún error.

Métodos de las expresiones regulares

Hay 16 métodos de Regexp que buscan coincidencias con 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, el método busca coincidencias sucesivas y no superpuestas de toda la expresión.
• Si String está presente, el argumento es un string; de lo contrario, es un slice de bytes; los valores de retorno se ajustan según corresponda.
• Si Submatch está presente, el valor de retorno 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 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 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 con 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 con 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 un slice con los substrings entre esas coincidencias de la expresión. El recuento n determina el número máximo de substrings a devolver. 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"}