Go by Example: Regular Expressions

Go ofrece soporte integrado para expresiones regulares. Aquí hay algunos ejemplos de tareas comunes relacionadas con regexp en Go.
	`package main`
	`import ( "bytes" "fmt" "regexp" )`
	`func main() {`
Esto prueba si un patrón coincide con una cadena.	`match, _ := regexp.MatchString("p([a-z]+)ch", "peach") fmt.Println(match)`
Arriba usamos un patrón de cadena directamente, pero para otras tareas de regexp necesitarás `Compile` una estructura `Regexp` optimizada.	`r, _ := regexp.Compile("p([a-z]+)ch")`
Hay muchos métodos disponibles en estas estructuras. Aquí hay una prueba de coincidencia como la que vimos anteriormente.	`fmt.Println(r.MatchString("peach"))`
Esto encuentra la coincidencia para la regexp.	`fmt.Println(r.FindString("peach punch"))`
Esto también encuentra la primera coincidencia pero devuelve los índices de inicio y fin para la coincidencia en lugar del texto coincidente.	`fmt.Println("idx:", r.FindStringIndex("peach punch"))`
Las variantes de `Submatch` incluyen información sobre las coincidencias del patrón completo y las subcoincidencias dentro de esas coincidencias. Por ejemplo, esto devolverá información tanto para `p([a-z]+)ch` como para `([a-z]+)`.	`fmt.Println(r.FindStringSubmatch("peach punch"))`
De manera similar, esto devolverá información sobre los índices de coincidencias y subcoincidencias.	`fmt.Println(r.FindStringSubmatchIndex("peach punch"))`
Las variantes de `All` de estas funciones se aplican a todas las coincidencias en la entrada, no solo a la primera. Por ejemplo, para encontrar todas las coincidencias de una regexp.	`fmt.Println(r.FindAllString("peach punch pinch", -1))`
Estas variantes de `All` están disponibles también para las otras funciones que vimos anteriormente.	`fmt.Println("all:", r.FindAllStringSubmatchIndex( "peach punch pinch", -1))`
Proporcionar un entero no negativo como segundo argumento a estas funciones limitará el número de coincidencias.	`fmt.Println(r.FindAllString("peach punch pinch", 2))`
Nuestros ejemplos anteriores tenían argumentos de cadena y usaban nombres como `MatchString`. También podemos proporcionar argumentos de `[]byte` y eliminar `String` del nombre de la función.	`fmt.Println(r.Match([]byte("peach")))`
Cuando creas variables globales con expresiones regulares, puedes usar la variación `MustCompile` de `Compile`. `MustCompile` genera un pánico en lugar de devolver un error, lo que lo hace más seguro para usar en variables globales.	`r = regexp.MustCompile("p([a-z]+)ch") fmt.Println("regexp:", r)`
El paquete `regexp` también puede ser utilizado para reemplazar subconjuntos de cadenas con otros valores.	`fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))`
La variante `Func` te permite transformar el texto coincidente con una función dada.	`in := []byte("a peach") out := r.ReplaceAllFunc(in, bytes.ToUpper) fmt.Println(string(out)) }`

	`$ go run regular-expressions.go true true peach idx: [0 5] [peach ea] [0 5 1 3] [peach punch pinch] all: [[0 5 1 3] [6 11 7 9] [12 17 13 15]] [peach punch] true regexp: p([a-z]+)ch a <fruit> a PEACH`
Para una referencia completa sobre las expresiones regulares de Go consulta la documentación del paquete `regexp`.

Siguiente ejemplo: JSON.