Expresiones regulares (Regex) del lenguaje Go

el paquete Regex de Go se utiliza para buscar cadenas de texto. Para buscar una cadena, necesitamos proporcionar un patrón de cadena.

我们需要将模式编译到regex对象中，以便我们可以通过它调用方法。

可以使用compile()和mustcompile()函数来检索正则表达式对象。现在我们可以使用函数来查找字符串，例如FindString()，FindStringSubmatch()，FindStringIndex()等。

expresiones regulares de ejemplo1

ejemplo

package main
import (
	"fmt"
	"regexp"
)
func　main()　{
	re := regexp.MustCompile(".com")
	fmt.Println(re.FindString("oldtoolbag.com"))
	fmt.Println(re.FindString("abc.org"))
	fmt.Println(re.FindString("fb.com"))
{}

Salida:

.com
.com

FindString()方法返回一个字符串，该字符串具有最左边匹配的文本。如果找不到匹配项，则返回空字符串。

expresiones regulares de ejemplo2

ejemplo

package main
import (
	"fmt"
	"regexp"
)
func　main()　{
	re := regexp.MustCompile(".com")
	fmt.Println(re.FindStringIndex("google.com"))
	fmt.Println(re.FindStringIndex("abc.org"))
	fmt.Println(re.FindStringIndex("fb.com"))
{}

Salida:

[6　10]
[]
[2　6]

expresiones regulares de ejemplo3

还可以使用FindStringSubmatch()方法，该方法返回具有最左边匹配项和匹配项文本的字符串切片。如果找不到匹配项，则返回值为空字符串。

ejemplo

package main
import (
	"fmt"
	"regexp"
)
func　main()　{
	re := regexp.MustCompile("f([a-z]+)ing")
	fmt.Println(re.FindStringSubmatch("flying"))
	fmt.Println(re.FindStringSubmatch("abcfloatingxyz"))
{}

Salida:

[vuelo ly]
[flotante float]
Proceso finalizado con código de salida 0

Métodos comunes del paquete regexp de Go

Para realizar coincidencias de expresiones regulares en el lenguaje Go, se puede usar el paquete regexp de Go 　

Las reglas de expresiones regulares en el lenguaje Go son las mismas que en otros lenguajes, solo difiere en las funciones llamadas 　　

Se recomienda usar el formato `pattern` al construir expresiones regulares.

regexp.Match

//　Determinar si se puede encontrar la subcadena que coincide con la expresión regular pattern en b
//　pattern: expresión regular a buscar
//　b: el []byte en el que se realizará la búsqueda
//　matched: devuelve si se encuentra o no un elemento coincidente
//　err: devuelve cualquier error que se encuentre durante el proceso de búsqueda
//　Esta función se implementa mediante el método de Regexp
func Match(pattern string, b []byte) (matched bool, err error)

Ejemplo en línea

package main
　
import (
　　　　"fmt"
　　　　"regexp"
)
　
func　main()　{
　　　　matched, err := regexp.Match("^abc.*z$, []byte("abcdefgz"))
　　　　fmt.Println(matched, err)　//true nil
　
　　　　matched, err = regexp.Match("^abc.*z$, []byte("bcdefgz"))
　　　　fmt.Println(matched, err)　//false nil
{}

regexp.MatchString

//　Determinar si se puede encontrar la subcadena que coincide con la expresión regular pattern en s
　//　pattern: expresión regular a buscar
　//　r: cadena en la que se realiza la búsqueda
　//　matched: devuelve si se encuentra o no un elemento coincidente
　//　err: devuelve cualquier error que se encuentre durante el proceso de búsqueda
　//　Esta función se implementa mediante el método de Regexp
　
　func MatchString(pattern string, s string) (matched bool, err error)

Ejemplo en línea

package main
　
import (
　　　　"fmt"
　　　　"regexp"
)
　
func　main()　{
　　　　matched, err := regexp.MatchString("^abc.*z$, "abcdefgz")
　　　　fmt.Println(matched, err)　//true <nil>
　
　　　　matched, err = regexp.MatchString("^abc.*z$, "bcdefgz")
　　　　fmt.Println(matched, err)　//false <nil>
{}

regexp.Compile

//　Compile se utiliza para analizar si la expresión regular expr es válida, si es válida, devuelve un objeto Regexp
//　El objeto Regexp puede ejecutar la operación necesaria en cualquier texto
func Compile(expr string) (*Regexp, error)

Devuelve un puntero a un objeto que implementa regexp, que se puede usar para invocar métodos definidos en regexp, como Match, MatchString, find, etc.

Ejemplo en línea

//func Compile(expr string) (*Regexp, error)
r, _ := regexp.Compile(`f([a-z]+)`)
　
//func　(re　*Regexp) Match(b []byte) bool
fmt.Println(r.Match([]byte("foo")))　//true
　
//func　(re　*Regexp) MatchString(s string) bool
fmt.Println(r.MatchString("foo"))　//true
　
//func　(re　*Regexp) FindString(s string) string
//Solo se realiza una coincidencia
fmt.Println(r.FindString("foo　func"))　//foo
　
//func　(re　*Regexp)　FindStringIndex(s　string)　(loc　[]int)
fmt.Println(r.FindStringIndex("demo　foo　func"))　//[5　8]
　
//func　(re　*Regexp) FindStringSubmatch(s string) []string
//Coincidir solo una vez, el valor en la posición 0 del resultado de coincidencia es el valor de la coincidencia completa, el segundo valor es el valor de la subexpresión
fmt.Println(r.FindStringSubmatch("this　foo　func　fan"))　//[foo　oo]
　
//Para FindStringSubmatch, si no hay subexpresiones en la expresión, no se detectan las subexpresiones
demo, _ := regexp.Compile(`foo`)
fmt.Println(demo.FindStringSubmatch("foo"))　//[foo]
　
//func　(re　*Regexp)　FindStringSubmatchIndex(s　string)　[]int
fmt.Println(r.FindStringSubmatchIndex("foo　func"))　//[0　3　1　3]
　
//func　(re　*Regexp)　FindAllString(s　string,　n　int)　[]string
//n es-1Al coincidir con todas las cadenas que cumplan con las condiciones, n no es-1Al coincidir n veces, representa coincidir solo n veces
fmt.Println(r.FindAllString("foo　func　fan",　-1))　//[foo　func　fan]
fmt.Println(r.FindAllString("foo　func　fan",　2))　　//[foo　func]
　
//func　(re　*Regexp)　FindAllStringSubmatchIndex(s　string,　n　int)　[][]int
//n también representa la cantidad de coincidencias-1Representa coincidir con todos
fmt.Println(r.FindAllStringSubmatchIndex("foo　func　demo　fan",　-1))
//[[0　3　1　3]] [4　8　5　8]] [14　17　15　17]]
　
//Reemplazar
　
//func　(re　*Regexp) ReplaceAll(src []byte, repl []byte) []byte
fmt.Println(string(r.ReplaceAll([]byte("this　is　foo,　that　is　func,　they　are　fan"),　[]byte("x"))))
//this　is　x,　that　is　x,　they　are　x
　
//func　(re　*Regexp) ReplaceAllString(src string, repl string) string
fmt.Println(r.ReplaceAllString("this　is　foo,　that　is　func,　they　are　fan",　"xx"))

regexp.MustCompile tiene un uso similar al de regexp.Compile

Explicación detallada del paquete regexp de Go para expresiones regulares

//　Explicación de regexp.go
------------------------------------------------------------
1.Determinar si se puede encontrar la subcadena que coincide con la expresión regular pattern en el []byte
//　pattern: expresión regular a buscar
//　b: el []byte en el que se realizará la búsqueda
//　matched: devuelve si se encuentra o no un elemento coincidente
//　err: devuelve cualquier error que se encuentre durante el proceso de búsqueda
//　Esta función se implementa mediante el método de Regexp
func Match(pattern string, b []byte) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.*　", []byte("Hello World!")))
//　true
{}
------------------------------------------------------------
2. evalúa si se puede encontrar la subcadena que coincide con la expresión regular pattern en r
//　pattern: expresión regular a buscar
//　r: interfaz RuneReader en la que se realiza la búsqueda
//　matched: devuelve si se encuentra o no un elemento coincidente
//　err: devuelve cualquier error que se encuentre durante el proceso de búsqueda
//　Esta función se implementa mediante el método de Regexp
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
func　main()　{
r :=　bytes.NewReader([]byte("Hello　World!"))
fmt.Println(regexp.MatchReader("H.*　", r))
//　true
{}
------------------------------------------------------------
3. evalúa si se puede encontrar la subcadena que coincide con la expresión regular pattern en s
//　pattern: expresión regular a buscar
//　r: cadena en la que se realiza la búsqueda
//　matched: devuelve si se encuentra o no un elemento coincidente
//　err: devuelve cualquier error que se encuentre durante el proceso de búsqueda
//　Esta función se implementa mediante el método de Regexp
func MatchString(pattern string, s string) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.*　", "Hello World!"))
//　true
{}
------------------------------------------------------------
4. QuoteMeta convierte los "caracteres especiales" de la cadena s a su "formato de escape"
//　Por ejemplo, QuoteMeta(`[foo]`) devuelve `
foo
。
//　Los caracteres especiales son: \.+*?()|[]{}^$
//　Estos caracteres se utilizan para implementar la gramática regular, por lo que se deben convertir cuando se utilizan como caracteres normales
func QuoteMeta(s string) string
func　main()　{
fmt.Println(regexp.QuoteMeta("(?P:Hello) [a-z]"))
//　\?P:Hello
a-z
{}
------------------------------------------------------------
5.Regexp estructura representa una expresión regular compilada
//　Las interfaces públicas de Regexp se implementan a través de métodos
//　Es seguro que varias goroutine utilicen un único RegExp de manera concurrente
type Regexp struct {
//　Campos privados
{}
//　a través de Complite, CompilePOSIX, MustCompile, MustCompilePOSIX
//　Cuatro funciones pueden crear un objeto Regexp
------------------------------------------------------------
6.Compile se utiliza para analizar si la expresión regular expr es válida. Si es válida, devuelve un objeto de tipo Regexp
//　El objeto Regexp puede ejecutar la operación necesaria en cualquier texto
func Compile(expr string) (*Regexp, error)
func　main()　{
reg, err := regexp.Compile(`\w+`)
fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)
//　"Hello"
{}
------------------------------------------------------------
7.CompilePOSIX tiene el mismo efecto que Compile
//　la diferencia es que CompilePOSIX utiliza la sintaxis POSIX
//　al mismo tiempo, utiliza la búsqueda más larga a la izquierda
//　mientras que Compile utiliza la búsqueda más larga a la izquierda
//　La sintaxis POSIX no admite la sintaxis de Perl: \d、\D、\s、\S、\w、\W
func CompilePOSIX(expr string) (*Regexp, error)
func　main()　{
reg, err := regexp.CompilePOSIX(`[[:word:]]+`)
fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)
//　"Hello"
{}
------------------------------------------------------------
8.MustCompile tiene el mismo efecto que Compile
//　la diferencia es que, cuando el expresión regular str no es válido, MustCompile lanzará una excepción
//　mientras que Compile solo devuelve un valor error
func MustCompile(str string)　*Regexp
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　Hello
{}
------------------------------------------------------------
9.MustCompilePOSIX tiene el mismo efecto que CompilePOSIX
//　la diferencia es que, cuando el expresión regular str no es válido, MustCompilePOSIX lanzará una excepción
//　mientras que CompilePOSIX solo devuelve un valor error
func MustCompilePOSIX(str string)　*Regexp
func　main()　{
reg := regexp.MustCompilePOSIX(`[[:word:]].+　`)
fmt.Printf("%q\n", reg.FindString("Hello World!"))
//　"Hello"
{}
------------------------------------------------------------
10. En []byte buscar el expresión regular compilada en re y devolver el primer contenido coincidente
func　(re　*Regexp) Find(b []byte) []byte
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.Find([]byte("Hello World!")))
//　"Hello"
{}
------------------------------------------------------------
11. En string buscar el expresión regular compilada en re y devolver el primer contenido coincidente
func　(re　*Regexp) FindString(s string) string
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　"Hello"
{}
------------------------------------------------------------
12.在　[]byte　中查找　re　中编译好的正则表达式，并返回所有匹配的内容
//　{{匹配项},　{匹配项},　...}
//　solo buscar los primeros n elementos coincidentes, si n < 0, buscar todos los elementos coincidentes
func　(re　*Regexp)　FindAll(b　[]byte,　n　int)　[][]byte
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q",　reg.FindAll([]byte("Hello　World!"),　-1))
//　["Hello"　"World"]
{}
------------------------------------------------------------
13En una cadena encontrar la expresión regular compilada en re y devolver todos los ajustes
//　{匹配项,　匹配项,　...}
//　solo buscar los primeros n elementos coincidentes, si n < 0, buscar todos los elementos coincidentes
func　(re　*Regexp)　FindAllString(s　string,　n　int)　[]string
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q",　reg.FindAllString("Hello　World!",　-1))
//　["Hello"　"World"]
{}
------------------------------------------------------------
14.　在　[]byte　中查找　re　中编译好的正则表达式，并返回第一个匹配的位置
//　{起始位置,　结束位置}
func　(re　*Regexp)　FindIndex(b　[]byte)　(loc　[]int)
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindIndex([]byte("Hello　World!")))
//　[0　5]
{}
------------------------------------------------------------
15.　在　string　中查找　re　中编译好的正则表达式，并返回第一个匹配的位置
//　{起始位置,　结束位置}
func　(re　*Regexp)　FindStringIndex(s　string)　(loc　[]int)
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindStringIndex("Hello　World!"))
//　[0　5]
{}
------------------------------------------------------------
16.En r buscar el expresión regular compilado en re y devolver la primera ubicación de coincidencia
//　{起始位置,　结束位置}
func　(re　*Regexp)　FindReaderIndex(r　io.RuneReader)　(loc　[]int)
func　main()　{
r :=　bytes.NewReader([]byte("Hello　World!"))
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindReaderIndex(r))
//　[0　5]
{}
------------------------------------------------------------
17.En []byte buscar el expresión regular compilado en re y devolver todas las ubicaciones de coincidencia
//　{{起始位置,　结束位置},　{起始位置,　结束位置},　...}
//　solo buscar los primeros n elementos coincidentes, si n < 0, buscar todos los elementos coincidentes
func　(re　*Regexp)　FindAllIndex(b　[]byte,　n　int)　[][]int
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindAllIndex([]byte("Hello　World!"),　-1))
//　[[0　5]] [6　11]]
{}
------------------------------------------------------------
18.En string buscar el expresión regular compilado en re y devolver todas las ubicaciones de coincidencia
//　{{起始位置,　结束位置},　{起始位置,　结束位置},　...}
//　solo buscar los primeros n elementos coincidentes, si n < 0, buscar todos los elementos coincidentes
func　(re　*Regexp)　FindAllStringIndex(s　string,　n　int)　[][]int
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindAllStringIndex("Hello　World!",　-1))
//　[[0　5]] [6　11]]
{}
------------------------------------------------------------
19En una cadena encontrar la expresión regular compilada en re y devolver el contenido del primer ajuste
//　devolviendo también el contenido de los subexpresiones
//　{{ajuste completo}, {subajuste}, {subajuste}, ...}
func　(re　*Regexp) FindSubmatch(b []byte) [][]byte
func　main()　{
reg :=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q", reg.FindSubmatch([]byte("Hello World!")))
//　["Hello" "H" "o"]
{}
------------------------------------------------------------
20. En una cadena encontrar la expresión regular compilada en re y devolver el contenido del primer ajuste
//　devolviendo también el contenido de los subexpresiones
//　{ajuste completo, subajuste, subajuste, ...}
func　(re　*Regexp) FindStringSubmatch(s string) []string
func　main()　{
reg :=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q", reg.FindStringSubmatch("Hello World!"))
//　["Hello" "H" "o"]
{}
------------------------------------------------------------
21En una cadena encontrar la expresión regular compilada en re y devolver todos los ajustes
//　devolviendo también el contenido de los subexpresiones
//　{
//　{{ajuste completo}, {subajuste}, {subajuste}, ...},
//　{{ajuste completo}, {subajuste}, {subajuste}, ...},
//　...
//　{}
func　(re　*Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
func　main()　{
reg :=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q", reg.FindAllSubmatch([]byte("Hello World!"),　-1))
//　[["Hello" "H" "o"] ["World" "W" "d"]]
{}
------------------------------------------------------------
22En una cadena encontrar la expresión regular compilada en re y devolver todos los ajustes
//　devolviendo también el contenido de los subexpresiones
//　{
//　{ajuste completo, subajuste, subajuste, ...},
//　{ajuste completo, subajuste, subajuste, ...},
//　...
//　{}
//　solo buscar los primeros n elementos coincidentes, si n < 0, buscar todos los elementos coincidentes
func　(re　*Regexp) FindAllStringSubmatch(s string, n int) [][]string
func　main()　{
reg :=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q", reg.FindAllStringSubmatch("Hello World!",　-1))
//　[["Hello" "H" "o"] ["World" "W" "d"]]
{}
------------------------------------------------------------
23En una cadena encontrar la expresión regular compilada en re y devolver la posición del primer ajuste
//　devolver al mismo tiempo la ubicación de la expresión subexpresión
//　{inicio del elemento completo, final del elemento completo, inicio del subelemento, final del subelemento, inicio del subelemento, final del subelemento, ...}
func　(re　*Regexp) FindSubmatchIndex(b []byte) []int
func　main()　{
reg :=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindSubmatchIndex([]byte("Hello World!")))
//　[0　5　0　1　4　5]
{}
------------------------------------------------------------
24En una cadena encontrar la expresión regular compilada en re y devolver la posición del primer ajuste
//　devolver al mismo tiempo la ubicación de la expresión subexpresión
//　{inicio del elemento completo, final del elemento completo, inicio del subelemento, final del subelemento, inicio del subelemento, final del subelemento, ...}
func　(re　*Regexp)　FindStringSubmatchIndex(s　string)　[]int
func　main()　{
reg :=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindStringSubmatchIndex("Hello　World!"))
//　[0　5　0　1　4　5]
{}
------------------------------------------------------------
25.En r buscar el expresión regular compilado en re y devolver la primera ubicación de coincidencia
//　devolver al mismo tiempo la ubicación de la expresión subexpresión
//　{inicio del elemento completo, final del elemento completo, inicio del subelemento, final del subelemento, inicio del subelemento, final del subelemento, ...}
func　(re　*Regexp)　FindReaderSubmatchIndex(r　io.RuneReader)　[]int
func　main()　{
r :=　bytes.NewReader([]byte("Hello　World!"))
reg :=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindReaderSubmatchIndex(r))
//　[0　5　0　1　4　5]
{}
------------------------------------------------------------
26.En []byte buscar el expresión regular compilado en re y devolver todas las ubicaciones de coincidencia
//　devolver al mismo tiempo la ubicación de la expresión subexpresión
//　{
//　{inicio del elemento completo, final del elemento completo, inicio del subelemento, final del subelemento, inicio del subelemento, final del subelemento, ...},
//　{inicio del elemento completo, final del elemento completo, inicio del subelemento, final del subelemento, inicio del subelemento, final del subelemento, ...},
//　...
//　{}
//　solo buscar los primeros n elementos coincidentes, si n < 0, buscar todos los elementos coincidentes
func　(re　*Regexp)　FindAllSubmatchIndex(b　[]byte,　n　int)　[][]int
func　main()　{
reg :=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindAllSubmatchIndex([]byte("Hello　World!"),　-1))
//　[[0　5　0　1　4　5]] [6　11　6　7　10　11]]
{}
------------------------------------------------------------
27.En string buscar el expresión regular compilado en re y devolver todas las ubicaciones de coincidencia
//　devolver al mismo tiempo la ubicación de la expresión subexpresión
//　{
//　{inicio del elemento completo, final del elemento completo, inicio del subelemento, final del subelemento, inicio del subelemento, final del subelemento, ...},
//　{inicio del elemento completo, final del elemento completo, inicio del subelemento, final del subelemento, inicio del subelemento, final del subelemento, ...},
//　...
//　{}
//　solo buscar los primeros n elementos coincidentes, si n < 0, buscar todos los elementos coincidentes
func　(re　*Regexp)　FindAllStringSubmatchIndex(s　string,　n　int)　[][]int
func　main()　{
reg :=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindAllStringSubmatchIndex("Hello　World!",　-1))
//　[[0　5　0　1　4　5]] [6　11　6　7　10　11]]
{}
-----------------------------------------------------------
30. Añadir el contenido del template procesado al final de dst
//　el template debe contener $1、$2、${name}1、${name}2tales "símbolos de referencia de grupo"}
//　match es el resultado devuelto por el método FindSubmatchIndex, que contiene la información de ubicación de cada grupo
//　Si el template contiene un "símbolo de referencia de grupo", se usa match como estándar,
//　Extrae la subcadena correspondiente de src y reemplázala en template con $1、$2　simbolos de citación.
func　(re　*Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
func　main()　{
reg := regexp.MustCompile(`(\w+,(\w+)`)
src := []byte("Golang,World!")　//　Texto de origen
dst := []byte("Say:")　//　Texto de destino
template := []byte("Hello $1, Hello $2")　//　Plantilla
match := reg.FindSubmatchIndex(src)　//　Analiza el texto de origen
//　Llena el plantilla y agrega el plantilla al texto de destino
fmt.Printf("%q", reg.Expand(dst, template, src, match))
//　"Say: Hello Golang, Hello World"
{}
------------------------------------------------------------
31. La función es la misma que Expand, solo que los parámetros se han cambiado a tipo string
func　(re　*Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte
func　main()　{
reg := regexp.MustCompile(`(\w+,(\w+)`)
src := "Golang,World!"　//　Texto de origen
dst := []byte("Say:")　//　Texto de destino (Editable)
template := "Hello $1, Hello $2"　//　Plantilla
match := reg.FindStringSubmatchIndex(src)　//　Analiza el texto de origen
//　Llena el plantilla y agrega el plantilla al texto de destino
fmt.Printf("%q", reg.ExpandString(dst, template, src, match))
//　"Say: Hello Golang, Hello World"
{}
------------------------------------------------------------
32. LiteralPrefix regresa el prefijo común compartido por todas las coincidencias (quitando elementos variables)
//　prefix: prefijo común compartido
//　complete: si el prefix es la expresión regular en sí misma, regresa true, de lo contrario regresa false
func　(re　*Regexp) LiteralPrefix() (prefix string, complete bool)
func　main()　{
reg := regexp.MustCompile(`Hello[\w\s])+`)
fmt.Println(reg.LiteralPrefix())
//　Hello false
reg = regexp.MustCompile(`Hello`)
fmt.Println(reg.LiteralPrefix())
//　Hello true
{}
------------------------------------------------------------
33. Cambiar a "modo voraz"
func　(re　*Regexp) Longest()
func　main()　{
text := `Hello World,　123　¡Sí!`
pattern := `(?U)H[\w\s]+o`　//　Marcador de expresión regular "modo no voraz" (?U)
reg := regexp.MustCompile(pattern)
fmt.Printf("%q\n", reg.FindString(text))
//　Hello
reg.Longest()　//　Cambiar a "modo voraz"
fmt.Printf("%q\n", reg.FindString(text))
//　Hello Wo
{}
------------------------------------------------------------
34. Determina si se puede encontrar un elemento coincidente en b
func　(re　*Regexp) Match(b []byte) bool
func　main()　{
b := []byte(`Hello World`)
reg := regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.Match(b))
//　false
reg = regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.Match(b))
//　true
{}
------------------------------------------------------------
35. Determina si se puede encontrar un elemento coincidente en r
func　(re　*Regexp) MatchReader(r io.RuneReader) bool
func　main()　{
r := bytes.NewReader([]byte(`Hello World`))
reg := regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.MatchReader(r))
//　false
r.Seek(0, 0)
reg = regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.MatchReader(r))
//　true
{}
------------------------------------------------------------
36. Determina si se puede encontrar un elemento coincidente en s
func　(re　*Regexp) MatchString(s string) bool
func　main()　{
s := `Hello World`
reg := regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.MatchString(s))
//　false
reg = regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.MatchString(s))
//　true
{}
------------------------------------------------------------
37. Estadísticas del número de grupos de expresión regular (sin incluir "grupos no capturados")
func　(re　*Regexp) NumSubexp() int
func　main()　{
reg := regexp.MustCompile(`(?U)(?:Hello)(\s+)(\w+)`)
fmt.Println(reg.NumSubexp())
//　2
{}
------------------------------------------------------------
38.Buscar coincidencias en src y reemplazarlas con el contenido especificado por repl
//　reemplaza todo y devuelve el resultado
func　(re　*Regexp) ReplaceAll(src, repl []byte) []byte
func　main()　{
b := []byte("Hello World,　123　Go!")
reg := regexp.MustCompile(`(Hell|G)o`)
rep := []byte("${1}ooo")
fmt.Printf("%q\n", reg.ReplaceAll(b, rep))
//　"Hellooo World,　123　Gooo!"
{}
------------------------------------------------------------
39.Buscar coincidencias en src y reemplazarlas con el contenido especificado por repl
//　reemplaza todo y devuelve el resultado
func　(re　*Regexp) ReplaceAllString(src, repl string) string
func　main()　{
s := "Hello World,　123　Go!"
reg := regexp.MustCompile(`(Hell|G)o`)
rep := "${1}ooo"
fmt.Printf("%q\n", reg.ReplaceAllString(s, rep))
//　"Hellooo World,　123　Gooo!"
{}
-----------------------------------------------------------
40.Buscar coincidencias en src y reemplazarlas con el contenido especificado por repl
//　Si repl contiene el "símbolo de referencia de grupo" ($1、$name)，entonces se trata al "símbolo de referencia de grupo" como un carácter común}}
//　reemplaza todo y devuelve el resultado
func　(re　*Regexp) ReplaceAllLiteral(src, repl []byte) []byte
func　main()　{
b := []byte("Hello World,　123　Go!")
reg := regexp.MustCompile(`(Hell|G)o`)
rep := []byte("${1}ooo")
fmt.Printf("%q\n", reg.ReplaceAllLiteral(b, rep))
//　"${1}ooo World,　123　${1}ooo!"
{}
-----------------------------------------------------------
41.Buscar coincidencias en src y reemplazarlas con el contenido especificado por repl
//　Si repl contiene el "símbolo de referencia de grupo" ($1、$name)，entonces se trata al "símbolo de referencia de grupo" como un carácter común}}
//　reemplaza todo y devuelve el resultado
func　(re　*Regexp) ReplaceAllLiteralString(src, repl string) string
func　main()　{
s := "Hello World,　123　Go!"
reg := regexp.MustCompile(`(Hell|G)o`)
rep := "${1}ooo"
fmt.Printf("%q\n", reg.ReplaceAllLiteralString(s, rep))
//　"${1}ooo World,　123　${1}ooo!"
{}
------------------------------------------------------------
42.Buscar coincidencias en src y luego reemplazar el contenido coincidente con el procesado por repl
//　Si el valor de retorno de repl contiene el "símbolo de referencia de grupo" ($1、$name)，entonces se trata al "símbolo de referencia de grupo" como un carácter común}}
//　reemplaza todo y devuelve el resultado
func　(re　*Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
func　main()　{
s := []byte("Hello World!")
reg　:=　regexp.MustCompile("(H)ello")
rep := []byte("$0$1")
fmt.Printf("%s\n", reg.ReplaceAll(s, rep))
//　
fmt.Printf("%s\n", reg.ReplaceAllFunc(s,
func(b []byte) []byte {
rst := []byte{}
rst = append(rst, b...)
rst = append(rst, "$1"...)
devolver rst
))
//　Hello$1　¡Mundo!
{}
k
------------------------------------------------------------
43.Buscar coincidencias en src y luego reemplazar el contenido coincidente con el procesado por repl
//　Si el valor de retorno de repl contiene el "símbolo de referencia de grupo" ($1、$name)，entonces se trata al "símbolo de referencia de grupo" como un carácter común}}
//　reemplaza todo y devuelve el resultado
func　(re　*Regexp)　ReplaceAllStringFunc(src　string,　repl　func(string)　string)　string
func　main()　{
s　:=　"Hello　World!"
reg　:=　regexp.MustCompile("(H)ello")
rep　:=　"$0$"1"
fmt.Printf("%s\n",　reg.ReplaceAllString(s,　rep))
//　
fmt.Printf("%s\n",　reg.ReplaceAllStringFunc(s,
func(b　string)　string　{
return　b　+　"$1"
))
//　Hello$1　¡Mundo!
{}
------------------------------------------------------------
43.busca coincidencias en s y divide s en varias subcadenas con los coincidencias como separadores
//　se pueden dividir hasta n subcadenas，la n-ésima subcadena no se divide
//　si　n　<　0，se dividen todas las subcadenas
//　devuelve la lista de subcadenas después de la división
func　(re　*Regexp)　Split(s　string,　n　int)　[]string
func　main()　{
s　:=　"Hello　World\tHello\nGolang"

fmt.Printf("%q\n",　reg.Split(s,　-1))
//　["Hello"　"Mundo"　"Hello"　"Golang"]
{}
------------------------------------------------------------
44.devuelve la cadena de "expresión regular" de re
func　(re　*Regexp)　String()　string
func　main()　{
re　:=　regexp.MustCompile("Hello.*$")
fmt.Printf("%s\n",　re.String())
//　Hello.*$
{}
------------------------------------------------------------
45.devuelve la lista de nombres de los grupos de re，para los grupos sin nombre devuelve una cadena vacía
//　el valor devuelto[0]　es el nombre de la expresión regular completa
//　el valor devuelto[1]　es un grupo　1　el nombre
//　el valor devuelto[2]　es un grupo　2　el nombre
//　……
func　(re　*Regexp)　SubexpNames()　[]string
func　main()　{
re　:=　regexp.MustCompile("(?PHello)　(Mundo)")
fmt.Printf("%q\n",　re.SubexpNames())
//　""　"Nombre1"  "
{}