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 utilizan 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 los tabuladores \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 esto, 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

Compilar patrones: el tipo RegExp

Para usar una expresión regular, primero debemos compilar el patrón de string. Aquí, compilar significa tomar el patrón de string de la expresión regular y convertirlo en una representación interna con la que sea 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*`)

Con esta función, no es necesario gestionar un error.

Métodos de expresiones regulares

Hay 16 métodos de Regexp que coinciden 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 encuentra 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 las 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 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 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 subcadenas separadas por la expresión y devuelve un slice de las subcadenas entre esas coincidencias de la expresión. El recuento n determina el número máximo de subcadenas que se devuelven. Si n<0, el método devuelve todas las subcadenas.

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"}