Regex del Linguaggio Go (Espressioni Regolari)

Il pacchetto Regex di Go viene utilizzato per cercare stringhe. Per cercare una stringa, dobbiamo fornire uno schema di stringa.

Dobbiamo compilare il modello nel objeto regex in modo che possiamo chiamare i metodi attraverso di esso.

Possiamo utilizzare le funzioni compile() e mustcompile() per ottenere l'oggetto dell'espressione regolare. Ora possiamo utilizzare le funzioni per cercare una stringa, ad esempio FindString(), FindStringSubmatch(), FindStringIndex() ecc.

Esempio di espressione regolare 1

Esempio

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

Output:

.com
.com

Il metodo FindString() restituisce una stringa che contiene il testo del match più a sinistra. Se non si trova alcun match, viene restituita una stringa vuota.

Esempio di espressione regolare 2

Esempio

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

Output:

[6 10]
[]
[2 6]

Esempio di espressione regolare 3

Possiamo anche utilizzare il metodo FindStringSubmatch(), che restituisce un'array di stringhe con il match più a sinistra e il testo del match. Se non si trova alcun match, il valore restituito è una stringa vuota.

Esempio

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

Output:

[volante ly]
[galleggiante float]
Processo completato con codice di uscita 0

Metodi comuni del pacchetto regexp dell'espressione regolare del linguaggio Go

La corrispondenza delle espressioni regolari del linguaggio Go può utilizzare il pacchetto regexp del linguaggio Go. 　

Le espressioni regolari del linguaggio Go sono le stesse delle espressioni regolari di altri linguaggi, la differenza sta solo nella funzione chiamata. 　　

Si raccomanda di utilizzare il formato `pattern` quando si costruisce un'espressione regolare.

regexp.Match

// Giudicare se è possibile trovare la sottostringa corrispondente all'espressione regolare pattern in b
// pattern: espressione regolare da cercare
// b: array di byte in cui cercare
// matched: restituisce se è stato trovato un elemento corrispondente
// err：返回查找过程中遇到的任何错误
// 此函数通过调用 Regexp 的方法实现
func Match(pattern string, b []byte) (matched bool, err error)

Esempio online

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

// Giudicare se è possibile trovare la sottostringa corrispondente all'espressione regolare pattern in s
　// pattern: espressione regolare da cercare
　// r: stringa in cui cercare
　// matched: restituisce se è stato trovato un elemento corrispondente
　// err：返回查找过程中遇到的任何错误
　// 此函数通过调用 Regexp 的方法实现
　
　func MatchString(pattern string, s string) (matched bool, err error)

Esempio online

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 utilizzato per analizzare se l'espressione regolare expr è valida, se è valida, restituisce un oggetto Regexp
// Regexp 对象可以在任意文本上执行需要的操作
func Compile(expr string) (*Regexp, error)

Restituisce un puntatore a un'istanza di regexp che ha implementato il metodo, come Match, MatchString, find, ecc.

Esempio online

//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
//Corrisponde solo una volta
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
//Corrisponde solo una volta, nel risultato del match, il valore dell'indice 0 è il valore della stringa di match completa, il secondo valore è il valore dell'espressione figlia
fmt.Println(r.FindStringSubmatch("this　foo　func　fan"))　//[foo　oo]
　
//Per FindStringSubmatch, se l'espressione non ha espressioni figlie, non si verifica
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 è -1 quando si matchano tutte le stringhe corrispondenti, n non è -1 quando si matchano solo n volte
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 è il numero di corrispondenze, -1 indica corrispondenze infinite
fmt.Println(r.FindAllStringSubmatchIndex("foo　func　demo　fan", -1))
// [[0 3 1 3] [4 8 5 8] [14 17 15 17]]
　
// sostituzione
　
// 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 è simile nell'uso a regexp.Compile

Dettagli del pacchetto regexp in Go

// regexp.go dettagliati
------------------------------------------------------------
1. Giudicare se è possibile trovare la sottostringa corrispondente all'espressione regolare pattern in []byte
// pattern: espressione regolare da cercare
// b: array di byte in cui cercare
// matched: restituisce se è stato trovato un elemento corrispondente
// err：返回查找过程中遇到的任何错误
// 此函数通过调用 Regexp 的方法实现
func Match(pattern string, b []byte) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.*　", []byte("Hello　World!")))
// true
}
------------------------------------------------------------
2. Giudicare se è possibile trovare la sottostringa corrispondente all'espressione regolare pattern in r
// pattern: espressione regolare da cercare
// r: interfaccia RuneReader in cui cercare
// matched: restituisce se è stato trovato un elemento corrispondente
// err：返回查找过程中遇到的任何错误
// 此函数通过调用 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. Giudicare se è possibile trovare la sottostringa corrispondente all'espressione regolare pattern in s
// pattern: espressione regolare da cercare
// r: stringa in cui cercare
// matched: restituisce se è stato trovato un elemento corrispondente
// err：返回查找过程中遇到的任何错误
// 此函数通过调用 Regexp 的方法实现
func MatchString(pattern string, s string) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.* ", "Hello World!"))
// true
}
------------------------------------------------------------
4. QuoteMeta 将字符串 s 中的“特殊字符”转换为其“转义格式”
// 例如，QuoteMeta(`[foo]`) 返回 `
foo
`。
// 特殊字符有：\.+*?()|[]{}^$
// 这些字符用于实现正则语法，所以当作普通字符使用时需要转换
func QuoteMeta(s string) string
func　main()　{
fmt.Println(regexp.QuoteMeta("(?P:Hello) [a-z]"))
// \?P:Hello
a−z
}
------------------------------------------------------------
5. Regexp 结构表示一个编译后的正则表达式
// Regexp 的公开接口都是通过方法实现的
// 多个 goroutine 并发使用一个 RegExp 是安全的
type Regexp struct {
// 私有字段
}
// 通过 Complite、CompilePOSIX、MustCompile、MustCompilePOSIX
// 四个函数可以创建一个 Regexp 对象
------------------------------------------------------------
6. Compile 用来解析正则表达式 expr 是否合法，如果合法，则返回一个 Regexp 对象
// Regexp 对象可以在任意文本上执行需要的操作
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 的作用和 Compile 一样
// 不同的是，CompilePOSIX 使用 POSIX 语法，
// 同时，它采用最左最长方式搜索，
// 而 Compile 采用最左最短方式搜索
// POSIX 语法不支持 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　ha la stessa funzione di　Compile
//　Diversamente, quando l'espressione regolare　str　non è valida, MustCompile　lancia un'eccezione
//　Compile　restituisce solo un valore di errore
func　MustCompile(str　string)　*Regexp
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
// Hello
}
------------------------------------------------------------
9.MustCompilePOSIX　ha la stessa funzione di　CompilePOSIX
//　Diversamente, quando l'espressione regolare　str　non è valida, MustCompilePOSIX　lancia un'eccezione
//　CompilePOSIX　restituisce solo un valore di errore
func　MustCompilePOSIX(str　string)　*Regexp
func　main()　{
reg　:=　regexp.MustCompilePOSIX(`[[:word:]].+　`)
fmt.Printf("%q\n",　reg.FindString("Hello　World!"))
//　"Hello　"
}
------------------------------------------------------------
10. Cercare in　[]byte　l'espressione regolare compilata in　re　e restituire il primo contenuto corrispondente
func　(re　*Regexp)　Find(b　[]byte)　[]byte
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q",　reg.Find([]byte("Hello　World!")))
//　"Hello"
}
------------------------------------------------------------
11. Cercare in　string　l'espressione regolare compilata in　re　e restituire il primo contenuto corrispondente
func　(re　*Regexp)　FindString(s　string)　string
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　"Hello"
}
------------------------------------------------------------
12. Cercare in　[]byte　l'espressione regolare compilata in　re　e restituire tutti i contenuti corrispondenti
//　{{elemento corrispondente},　{elemento corrispondente},　...}
// solo ricerca i primi n elementi corrispondenti, se n < 0, ricerca tutti gli elementi corrispondenti
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"]
}
------------------------------------------------------------
13. Cerca in stringa l'espressione regolare compilata in re e restituisce tutte le corrispondenze
// {corrispondenza, corrispondenza, ...}
// solo ricerca i primi n elementi corrispondenti, se n < 0, ricerca tutti gli elementi corrispondenti
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. Cerca in []byte l'espressione regolare compilata in re e restituisce la prima posizione di corrispondenza
// {inizio, fine}
func (re *Regexp) FindIndex(b []byte) (loc []int)
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindIndex([]byte("Hello World!")))
// [0 5]
}
------------------------------------------------------------
15. Cerca in stringa l'espressione regolare compilata in re e restituisce la prima posizione di corrispondenza
// {inizio, fine}
func (re *Regexp) FindStringIndex(s string) (loc []int)
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindStringIndex("Hello World!"))
// [0 5]
}
------------------------------------------------------------
16. Cerca in r l'espressione regolare compilata in re e restituisce la prima posizione di corrispondenza
// {inizio, fine}
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. Cerca in []byte l'espressione regolare compilata in re e restituisce tutte le posizioni di corrispondenza
// {{inizio, fine}, {inizio, fine}, ...}
// solo ricerca i primi n elementi corrispondenti, se n < 0, ricerca tutti gli elementi corrispondenti
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. Cerca in stringa il'espressione regolare compilata in re e restituisce tutte le posizioni di corrispondenza
// {{inizio, fine}, {inizio, fine}, ...}
// solo ricerca i primi n elementi corrispondenti, se n < 0, ricerca tutti gli elementi corrispondenti
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]]
}
------------------------------------------------------------
19. Cerca in []byte la espressione regolare compilata in re e restituisce la prima corrispondenza
//　e restituisce il contenuto delle espressioni regolari
//　{{completamente corrispondente},　{corrispondenza secondaria},　{corrispondenza secondaria},　...}
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. Cerca la stringa in stringa e restituisce la prima corrispondenza
//　e restituisce il contenuto delle espressioni regolari
//　{completamente corrispondente,　corrispondenza secondaria,　corrispondenza secondaria,　...}
func　(re　*Regexp)　FindStringSubmatch(s　string)　[]string
func　main()　{
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q",　reg.FindStringSubmatch("Hello　World!"))
//　["Hello"　"H"　"o"]
}
------------------------------------------------------------
21. Cerca in []byte la espressione regolare compilata in re e restituisce tutte le corrispondenze
//　e restituisce il contenuto delle espressioni regolari
// {
//　{{completamente corrispondente},　{corrispondenza secondaria},　{corrispondenza secondaria},　...}
//　{{completamente corrispondente},　{corrispondenza secondaria},　{corrispondenza secondaria},　...}
// ...
// }
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"]]
}
------------------------------------------------------------
22. Cerca la stringa in stringa e restituisce tutte le corrispondenze
//　e restituisce il contenuto delle espressioni regolari
// {
//　{completamente corrispondente,　corrispondenza secondaria,　corrispondenza secondaria,　...}
//　{completamente corrispondente,　corrispondenza secondaria,　corrispondenza secondaria,　...}
// ...
// }
// solo ricerca i primi n elementi corrispondenti, se n < 0, ricerca tutti gli elementi corrispondenti
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"]]
}
------------------------------------------------------------
23. Cerca l'espressione regolare compilata in re in []byte e restituisce la posizione della prima corrispondenza
// restituisce anche la posizione della corrispondenza dell'espressione secondaria
// {inizio elemento completo, fine elemento completo, inizio sottoelemento, fine sottoelemento, inizio sottoelemento, fine sottoelemento, ...}
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]
}
------------------------------------------------------------
24. Cerca l'espressione regolare compilata in re nella stringa e restituisce la posizione della prima corrispondenza
// restituisce anche la posizione della corrispondenza dell'espressione secondaria
// {inizio elemento completo, fine elemento completo, inizio sottoelemento, fine sottoelemento, inizio sottoelemento, fine sottoelemento, ...}
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. Cerca l'espressione regolare compilata in re in r e restituisce la posizione della prima corrispondenza
// restituisce anche la posizione della corrispondenza dell'espressione secondaria
// {inizio elemento completo, fine elemento completo, inizio sottoelemento, fine sottoelemento, inizio sottoelemento, fine sottoelemento, ...}
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. Cerca l'espressione regolare compilata in re in []byte e restituisce tutte le posizioni delle corrispondenze
// restituisce anche la posizione della corrispondenza dell'espressione secondaria
// {
// {inizio elemento completo, fine elemento completo, inizio sottoelemento, fine sottoelemento, inizio sottoelemento, fine sottoelemento, ...},
// {inizio elemento completo, fine elemento completo, inizio sottoelemento, fine sottoelemento, inizio sottoelemento, fine sottoelemento, ...},
// ...
// }
// solo ricerca i primi n elementi corrispondenti, se n < 0, ricerca tutti gli elementi corrispondenti
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. Cerca l'espressione regolare compilata in re nella stringa e restituisce tutte le posizioni delle corrispondenze
// restituisce anche la posizione della corrispondenza dell'espressione secondaria
// {
// {inizio elemento completo, fine elemento completo, inizio sottoelemento, fine sottoelemento, inizio sottoelemento, fine sottoelemento, ...},
// {inizio elemento completo, fine elemento completo, inizio sottoelemento, fine sottoelemento, inizio sottoelemento, fine sottoelemento, ...},
// ...
// }
// solo ricerca i primi n elementi corrispondenti, se n < 0, ricerca tutti gli elementi corrispondenti
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. Aggiungere il contenuto del template elaborato alla fine di dst
// Nel modello devono essere presenti $1, $2, ${name1}, ${name2} e simili "simboli di riferimento di gruppo"
// match è il risultato restituito dal metodo FindSubmatchIndex, che contiene le informazioni sulla posizione di ciascun gruppo
// Se il modello contiene "simboli di riferimento di gruppo", utilizzare match come standard
// Estrarre la sottostringa corrispondente da src e sostituire i simboli di riferimento $1, $2 nel modello
func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
func　main()　{
reg := regexp.MustCompile(`(\w+),(\w+)`)
src := []byte("Golang,World!") // testo sorgente
dst := []byte("Say: ") // testo di destinazione
template := []byte("Hello $1, Hello $2") // modello
match := reg.FindSubmatchIndex(src) // analizzare il testo sorgente
// Compilare il modello e aggiungere il modello al testo di destinazione
fmt.Printf("%q", reg.Expand(dst, template, src, match))
// "Say: Hello Golang, Hello World"
}
------------------------------------------------------------
31. La funzione è la stessa di Expand, ma i parametri sono di 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!" // testo sorgente
dst := []byte("Say: ") // testo di destinazione (scrivibile)
template := "Hello $1, Hello $2" // modello
match := reg.FindStringSubmatchIndex(src) // Analizzare il testo sorgente
// Compilare il modello e aggiungere il modello al testo di destinazione
fmt.Printf("%q", reg.ExpandString(dst, template, src, match))
// "Say: Hello Golang, Hello World"
}
------------------------------------------------------------
32. LiteralPrefix restituisce il prefisso comune a tutte le corrispondenze (rimuovendo gli elementi variabili)
// prefix: Prefisso comune
// complete: Se il prefix è la stessa espressione regolare, restituisce true, altrimenti 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. Passare a modalità 'greedy'
func (re *Regexp) Longest()
func　main()　{
text := `Hello　World,　123　Go!`
pattern := `(?U)H[\w\s]+o` // Marchio regolare 'non greedy' (?U)
reg := regexp.MustCompile(pattern)
fmt.Printf("%q\n", reg.FindString(text))
// Hello
reg.Longest() // Passare a modalità 'greedy'
fmt.Printf("%q\n", reg.FindString(text))
// Hello Wo
}
------------------------------------------------------------
34. Giudicare se è possibile trovare un elemento corrispondente in 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. Giudicare se è possibile trovare un elemento corrispondente in 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. Determine if a matching item can be found in 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. Count the number of groups in the regular expression (excluding "non-capturing groups")
func　(re　*Regexp)　NumSubexp()　int
func　main()　{
reg　:=　regexp.MustCompile(`(?U)(?:Hello)(\s+)(\w+)`)
fmt.Println(reg.NumSubexp())
// 2
}
------------------------------------------------------------
38. In src search for matching items and replace them with the content specified by repl
// 全部替换，并返回替换后的结果
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. In src search for matching items and replace them with the content specified by repl
// 全部替换，并返回替换后的结果
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. In src search for matching items and replace them with the content specified by repl
// 如果 repl 中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
// 全部替换，并返回替换后的结果
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. 在 src 中搜索匹配项，并替换为 repl 指定的内容
// 如果 repl 中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
// 全部替换，并返回替换后的结果
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. 在 src 中搜索匹配项，然后将匹配的内容经过 repl 处理后，替换 src 中的匹配项
// 如果 repl 的返回值中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
// 全部替换，并返回替换后的结果
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))
//　HelloH　World!
fmt.Printf("%s\n", reg.ReplaceAllFunc(s,))
func (b []byte) []byte {
rst := []byte{}
rst = append(rst, b...)
rst = append(rst, "$1"...)
return rst
))
//　Hello$1　World!
}
k
------------------------------------------------------------
43. 在 src 中搜索匹配项，然后将匹配的内容经过 repl 处理后，替换 src 中的匹配项
// 如果 repl 的返回值中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
// 全部替换，并返回替换后的结果
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))
//　HelloH　World!
fmt.Printf("%s\n",　reg.ReplaceAllStringFunc(s,
func(b　string)　string　{
return　b　+　"$1"
))
//　Hello$1　World!
}
------------------------------------------------------------
43.在　s　中搜索匹配项，并以匹配项为分割符，将　s　分割成多个子串
//　最多分割出　n　个子串，第　n　个子串不再进行分割
//　如果　n　<　0，则分割所有子串
//　返回分割后的子串列表
func　(re　*Regexp)　Split(s　string,　n　int)　[]string
func　main()　{
s　:=　"Hello　World\tHello\nGolang"
reg　:=　regexp.MustCompile(`\s`)
fmt.Printf("%q\n",　reg.Split(s,　-1))
//　["Hello"　"World"　"Hello"　"Golang"]
}
------------------------------------------------------------
44.返回　re　中的“正则表达式”字符串
func　(re　*Regexp)　String()　string
func　main()　{
re　:=　regexp.MustCompile("Hello.*$")
fmt.Printf("%s\n",　re.String())
//　Hello.*$
}
------------------------------------------------------------
45.返回　re　中的分组名称列表，未命名的分组返回空字符串
//　返回值[0]　为整个正则表达式的名称
//　返回值[1]　是分组　1　的名称
//　返回值[2]　是分组　2　的名称
//　……
func　(re　*Regexp)　SubexpNames()　[]string
func　main()　{
re　:=　regexp.MustCompile("(?PHello)　(World)")
fmt.Printf("%q\n",　re.SubexpNames())
//　[""　"Name1"　"]
}