Golang 菜鳥(niǎo)教程

Golang 控制語(yǔ)句

Golang 函數(shù) & 方法

Golang 結(jié)構(gòu)體

Golang 切片 & 數(shù)組

Golang 字符串(String)

Golang 指針

Golang 接口

Golang 并發(fā)

Golang 異常(Error)

Golang 其他雜項(xiàng)

Go Regex(正則表達(dá)式)

Go Regex包用于搜索字符串。要搜索字符串，我們需要提供字符串模式。

我們需要將模式編譯到regex對(duì)象中，以便我們可以通過(guò)它調(diào)用方法。

可以使用compile()和mustcompile()函數(shù)來(lái)檢索正則表達(dá)式對(duì)象。現(xiàn)在我們可以使用函數(shù)來(lái)查找字符串，例如FindString()，F(xiàn)indStringSubmatch()，F(xiàn)indStringIndex()等。

正則表達(dá)式示例1

package main

import (
	"fmt"
	"regexp"
)

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

輸出：

.com

.com

FindString()方法返回一個(gè)字符串，該字符串具有最左邊匹配的文本。如果找不到匹配項(xiàng)，則返回空字符串。

正則表達(dá)式示例2

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

輸出：

[6 10]
[]
[2 6]

正則表達(dá)式示例3

我們還可以使用FindStringSubmatch()方法，該方法返回具有最左邊匹配項(xiàng)和匹配項(xiàng)文本的字符串切片。如果找不到匹配項(xiàng)，則返回值為空字符串。

package main

import (
	"fmt"
	"regexp"
)

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

輸出：

[flying ly]
[floating loat]

Process finished with exit code 0

Go 語(yǔ)言正則表達(dá)式 regexp 包中常用方法

go語(yǔ)言的正則表達(dá)式匹配，可以使用go語(yǔ)言的regexp包。 　

go語(yǔ)言的正則表達(dá)式和其他語(yǔ)言的正則表達(dá)式規(guī)則都是一樣的，只是調(diào)用的函數(shù)不同而已 　　

推薦在構(gòu)造正則表達(dá)式時(shí)，使用` pattern `格式。

regexp.Match

// 判斷在 b 中能否找到正則表達(dá)式 pattern 所匹配的子串
// pattern：要查找的正則表達(dá)式
// b：要在其中進(jìn)行查找的 []byte
// matched：返回是否找到匹配項(xiàng)
// err：返回查找過(guò)程中遇到的任何錯(cuò)誤
// 此函數(shù)通過(guò)調(diào)用 Regexp 的方法實(shí)現(xiàn)

func Match(pattern string, b []byte) (matched bool, err error)

在線(xiàn)示例

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

// 判斷在 s 中能否找到正則表達(dá)式 pattern 所匹配的子串
 // pattern：要查找的正則表達(dá)式
 // r：要在其中進(jìn)行查找的字符串
 // matched：返回是否找到匹配項(xiàng)
 // err：返回查找過(guò)程中遇到的任何錯(cuò)誤
 // 此函數(shù)通過(guò)調(diào)用 Regexp 的方法實(shí)現(xiàn)
 
 func MatchString(pattern string, s string) (matched bool, err error)

在線(xiàn)示例

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 用來(lái)解析正則表達(dá)式 expr 是否合法，如果合法，則返回一個(gè) Regexp 對(duì)象
// Regexp 對(duì)象可以在任意文本上執(zhí)行需要的操作
func Compile(expr string) (*Regexp, error)

返回一個(gè)實(shí)現(xiàn)了regexp的對(duì)象指針，可以使用返回值調(diào)用regexp中定義的方法，如Match，MatchString，find等。

在線(xiàn)示例

//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
//只匹配一次
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
//只匹配一次，返回的結(jié)果中，索引為0的值是整個(gè)匹配串的值，第二個(gè)值是子表達(dá)式的值
fmt.Println(r.FindStringSubmatch("this foo func fan")) //[foo oo]
 
//對(duì)于FindStringSubmatch，如果表達(dá)式中沒(méi)有子表達(dá)式，則不檢測(cè)子表達(dá)式
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時(shí)，匹配所有符合條件的字符串，n不為-1時(shí)，表示只匹配n次
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同樣是表示匹配的次數(shù)，-1表示匹配所有
fmt.Println(r.FindAllStringSubmatchIndex("foo func demo fan", -1))
//[[0 3 1 3] [4 8 5 8] [14 17 15 17]]
 
//替換
 
//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 和上面的regexp.Compile用法相似。

Go語(yǔ)言正則表達(dá)式 regexp 包詳解

// regexp.go 詳解

------------------------------------------------------------
1.判斷在 []byte 中能否找到正則表達(dá)式 pattern 所匹配的子串

// pattern：要查找的正則表達(dá)式
// b：要在其中進(jìn)行查找的 []byte
// matched：返回是否找到匹配項(xiàng)
// err：返回查找過(guò)程中遇到的任何錯(cuò)誤
// 此函數(shù)通過(guò)調(diào)用 Regexp 的方法實(shí)現(xiàn)
func Match(pattern string, b []byte) (matched bool, err error)

func main() {
fmt.Println(regexp.Match("H.* ", []byte("Hello World!")))
// true
}

------------------------------------------------------------
2. 判斷在 r 中能否找到正則表達(dá)式 pattern 所匹配的子串

// pattern：要查找的正則表達(dá)式
// r：要在其中進(jìn)行查找的 RuneReader 接口
// matched：返回是否找到匹配項(xiàng)
// err：返回查找過(guò)程中遇到的任何錯(cuò)誤
// 此函數(shù)通過(guò)調(diào)用 Regexp 的方法實(shí)現(xiàn)
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. 判斷在 s 中能否找到正則表達(dá)式 pattern 所匹配的子串

// pattern：要查找的正則表達(dá)式
// r：要在其中進(jìn)行查找的字符串
// matched：返回是否找到匹配項(xiàng)
// err：返回查找過(guò)程中遇到的任何錯(cuò)誤
// 此函數(shù)通過(guò)調(diào)用 Regexp 的方法實(shí)現(xiàn)
func MatchString(pattern string, s string) (matched bool, err error)

func main() {
fmt.Println(regexp.Match("H.* ", "Hello World!"))
// true
}

------------------------------------------------------------
4. QuoteMeta 將字符串 s 中的“特殊字符”轉(zhuǎn)換為其“轉(zhuǎn)義格式”

// 例如，QuoteMeta（`[foo]`）返回`
foo
`。
// 特殊字符有：\.+*?()|[]{}^$
// 這些字符用于實(shí)現(xiàn)正則語(yǔ)法，所以當(dāng)作普通字符使用時(shí)需要轉(zhuǎn)換
func QuoteMeta(s string) string

func main() {
fmt.Println(regexp.QuoteMeta("(?P:Hello) [a-z]"))
// \?P:Hello
a?z


}

------------------------------------------------------------
5.Regexp 結(jié)構(gòu)表示一個(gè)編譯后的正則表達(dá)式

// Regexp 的公開(kāi)接口都是通過(guò)方法實(shí)現(xiàn)的
// 多個(gè) goroutine 并發(fā)使用一個(gè) RegExp 是安全的
type Regexp struct {
// 私有字段
}

// 通過(guò) Complite、CompilePOSIX、MustCompile、MustCompilePOSIX
// 四個(gè)函數(shù)可以創(chuàng)建一個(gè) Regexp 對(duì)象

------------------------------------------------------------
6.Compile 用來(lái)解析正則表達(dá)式 expr 是否合法，如果合法，則返回一個(gè) Regexp 對(duì)象

// Regexp 對(duì)象可以在任意文本上執(zhí)行需要的操作
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 語(yǔ)法，
// 同時(shí)，它采用最左最長(zhǎng)方式搜索，
// 而 Compile 采用最左最短方式搜索
// POSIX 語(yǔ)法不支持 Perl 的語(yǔ)法格式：\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 的作用和 Compile 一樣

// 不同的是，當(dāng)正則表達(dá)式 str 不合法時(shí)，MustCompile 會(huì)拋出異常
// 而 Compile 僅返回一個(gè) error 值
func MustCompile(str string) *Regexp

func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello World!"))
// Hello
}

------------------------------------------------------------
9.MustCompilePOSIX 的作用和 CompilePOSIX 一樣

// 不同的是，當(dāng)正則表達(dá)式 str 不合法時(shí)，MustCompilePOSIX 會(huì)拋出異常
// 而 CompilePOSIX 僅返回一個(gè) error 值
func MustCompilePOSIX(str string) *Regexp

func main() {
reg := regexp.MustCompilePOSIX(`[[:word:]].+ `)
fmt.Printf("%q\n", reg.FindString("Hello World!"))
// "Hello "
}

------------------------------------------------------------
10. 在 []byte中查找 re 中編譯好的正則表達(dá)式，并返回第一個(gè)匹配的內(nèi)容

func (re *Regexp) Find(b []byte) []byte

func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.Find([]byte("Hello World!")))
// "Hello"
}

------------------------------------------------------------
11.在 string 中查找 re 中編譯好的正則表達(dá)式，并返回第一個(gè)匹配的內(nèi)容

func (re *Regexp) FindString(s string) string

func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello World!"))
// "Hello"
}

------------------------------------------------------------
12.在 []byte 中查找 re 中編譯好的正則表達(dá)式，并返回所有匹配的內(nèi)容

// {{匹配項(xiàng)}, {匹配項(xiàng)}, ...}
// 只查找前 n 個(gè)匹配項(xiàng)，如果 n < 0，則查找所有匹配項(xiàng)
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.在 string 中查找 re 中編譯好的正則表達(dá)式，并返回所有匹配的內(nèi)容

// {匹配項(xiàng), 匹配項(xiàng), ...}
// 只查找前 n 個(gè)匹配項(xiàng)，如果 n < 0，則查找所有匹配項(xiàng)
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 中編譯好的正則表達(dá)式，并返回第一個(gè)匹配的位置

// {起始位置, 結(jié)束位置}
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 中編譯好的正則表達(dá)式，并返回第一個(gè)匹配的位置

// {起始位置, 結(jié)束位置}
func (re *Regexp) FindStringIndex(s string) (loc []int)

func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindStringIndex("Hello World!"))
// [0 5]
}

------------------------------------------------------------
16.在 r 中查找 re 中編譯好的正則表達(dá)式，并返回第一個(gè)匹配的位置

// {起始位置, 結(jié)束位置}
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.在 []byte 中查找 re 中編譯好的正則表達(dá)式，并返回所有匹配的位置

// {{起始位置, 結(jié)束位置}, {起始位置, 結(jié)束位置}, ...}
// 只查找前 n 個(gè)匹配項(xiàng)，如果 n < 0，則查找所有匹配項(xiàng)
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.在 string 中查找 re 中編譯好的正則表達(dá)式，并返回所有匹配的位置

// {{起始位置, 結(jié)束位置}, {起始位置, 結(jié)束位置}, ...}
// 只查找前 n 個(gè)匹配項(xiàng)，如果 n < 0，則查找所有匹配項(xiàng)
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. 在 []byte 中查找 re 中編譯好的正則表達(dá)式，并返回第一個(gè)匹配的內(nèi)容

// 同時(shí)返回子表達(dá)式匹配的內(nèi)容
// {{完整匹配項(xiàng)}, {子匹配項(xiàng)}, {子匹配項(xiàng)}, ...}
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.在 string 中查找 re 中編譯好的正則表達(dá)式，并返回第一個(gè)匹配的內(nèi)容

// 同時(shí)返回子表達(dá)式匹配的內(nèi)容
// {完整匹配項(xiàng), 子匹配項(xiàng), 子匹配項(xiàng), ...}
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. 在 []byte 中查找 re 中編譯好的正則表達(dá)式，并返回所有匹配的內(nèi)容

// 同時(shí)返回子表達(dá)式匹配的內(nèi)容
// {
// {{完整匹配項(xiàng)}, {子匹配項(xiàng)}, {子匹配項(xiàng)}, ...},
// {{完整匹配項(xiàng)}, {子匹配項(xiàng)}, {子匹配項(xiàng)}, ...},
// ...
// }
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.在 string 中查找 re 中編譯好的正則表達(dá)式，并返回所有匹配的內(nèi)容

// 同時(shí)返回子表達(dá)式匹配的內(nèi)容
// {
// {完整匹配項(xiàng), 子匹配項(xiàng), 子匹配項(xiàng), ...},
// {完整匹配項(xiàng), 子匹配項(xiàng), 子匹配項(xiàng), ...},
// ...
// }
// 只查找前 n 個(gè)匹配項(xiàng)，如果 n < 0，則查找所有匹配項(xiàng)
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.在 []byte 中查找 re 中編譯好的正則表達(dá)式，并返回第一個(gè)匹配的位置

// 同時(shí)返回子表達(dá)式匹配的位置
// {完整項(xiàng)起始, 完整項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, ...}
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.在 string 中查找 re 中編譯好的正則表達(dá)式，并返回第一個(gè)匹配的位置

// 同時(shí)返回子表達(dá)式匹配的位置
// {完整項(xiàng)起始, 完整項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, ...}
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.在 r 中查找 re 中編譯好的正則表達(dá)式，并返回第一個(gè)匹配的位置

// 同時(shí)返回子表達(dá)式匹配的位置
// {完整項(xiàng)起始, 完整項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, ...}
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.在 []byte 中查找 re 中編譯好的正則表達(dá)式，并返回所有匹配的位置

// 同時(shí)返回子表達(dá)式匹配的位置
// {
// {完整項(xiàng)起始, 完整項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, ...},
// {完整項(xiàng)起始, 完整項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, ...},
// ...
// }
// 只查找前 n 個(gè)匹配項(xiàng)，如果 n < 0，則查找所有匹配項(xiàng)
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.在 string 中查找 re 中編譯好的正則表達(dá)式，并返回所有匹配的位置

// 同時(shí)返回子表達(dá)式匹配的位置
// {
// {完整項(xiàng)起始, 完整項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, ...},
// {完整項(xiàng)起始, 完整項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, 子項(xiàng)起始, 子項(xiàng)結(jié)束, ...},
// ...
// }
// 只查找前 n 個(gè)匹配項(xiàng)，如果 n < 0，則查找所有匹配項(xiàng)
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. 將 template 的內(nèi)容經(jīng)過(guò)處理后，追加到 dst 的尾部

// template 中要有 $1、$2、${name1}、${name2} 這樣的“分組引用符”
// match 是由 FindSubmatchIndex 方法返回的結(jié)果，里面存放了各個(gè)分組的位置信息
// 如果 template 中有“分組引用符”，則以 match 為標(biāo)準(zhǔn)，
// 在 src 中取出相應(yīng)的子串，替換掉 template 中的 $1、$2 等引用符號(hào)。
func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte

func main() {
reg := regexp.MustCompile(`(\w+),(\w+)`)
src := []byte("Golang,World!") // 源文本
dst := []byte("Say: ") // 目標(biāo)文本
template := []byte("Hello $1, Hello $2") // 模板
match := reg.FindSubmatchIndex(src) // 解析源文本
// 填寫(xiě)模板，并將模板追加到目標(biāo)文本中
fmt.Printf("%q", reg.Expand(dst, template, src, match))
// "Say: Hello Golang, Hello World"
}

------------------------------------------------------------
31.功能同 Expand 一樣，只不過(guò)參數(shù)換成了 string 類(lèi)型

func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte

func main() {
reg := regexp.MustCompile(`(\w+),(\w+)`)
src := "Golang,World!" // 源文本
dst := []byte("Say: ") // 目標(biāo)文本（可寫(xiě)）
template := "Hello $1, Hello $2" // 模板
match := reg.FindStringSubmatchIndex(src) // 解析源文本
// 填寫(xiě)模板，并將模板追加到目標(biāo)文本中
fmt.Printf("%q", reg.ExpandString(dst, template, src, match))
// "Say: Hello Golang, Hello World"
}

------------------------------------------------------------
32. LiteralPrefix 返回所有匹配項(xiàng)都共同擁有的前綴（去除可變?cè)兀?

// prefix：共同擁有的前綴
// complete：如果 prefix 就是正則表達(dá)式本身，則返回 true，否則返回 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. 切換到“貪婪模式”

func (re *Regexp) Longest()

func main() {
text := `Hello World, 123 Go!`
pattern := `(?U)H[\w\s]+o` // 正則標(biāo)記“非貪婪模式”(?U)
reg := regexp.MustCompile(pattern)
fmt.Printf("%q\n", reg.FindString(text))
// Hello
reg.Longest() // 切換到“貪婪模式”
fmt.Printf("%q\n", reg.FindString(text))
// Hello Wo
}

------------------------------------------------------------
34.判斷在 b 中能否找到匹配項(xiàng)

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.判斷在 r 中能否找到匹配項(xiàng)

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.判斷在 s 中能否找到匹配項(xiàng)

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. 統(tǒng)計(jì)正則表達(dá)式中的分組個(gè)數(shù)（不包括“非捕獲的分組”）

func (re *Regexp) NumSubexp() int

func main() {
reg := regexp.MustCompile(`(?U)(?:Hello)(\s+)(\w+)`)
fmt.Println(reg.NumSubexp())
// 2
}

------------------------------------------------------------
38.在 src 中搜索匹配項(xiàng)，并替換為 repl 指定的內(nèi)容

// 全部替換，并返回替換后的結(jié)果
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.在 src 中搜索匹配項(xiàng)，并替換為 repl 指定的內(nèi)容

// 全部替換，并返回替換后的結(jié)果
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.在 src 中搜索匹配項(xiàng)，并替換為 repl 指定的內(nèi)容

// 如果 repl 中有“分組引用符”（$1、$name），則將“分組引用符”當(dāng)普通字符處理
// 全部替換，并返回替換后的結(jié)果
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 中搜索匹配項(xiàng)，并替換為 repl 指定的內(nèi)容

// 如果 repl 中有“分組引用符”（$1、$name），則將“分組引用符”當(dāng)普通字符處理
// 全部替換，并返回替換后的結(jié)果
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 中搜索匹配項(xiàng)，然后將匹配的內(nèi)容經(jīng)過(guò) repl 處理后，替換 src 中的匹配項(xiàng)

// 如果 repl 的返回值中有“分組引用符”（$1、$name），則將“分組引用符”當(dāng)普通字符處理
// 全部替換，并返回替換后的結(jié)果
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 中搜索匹配項(xiàng)，然后將匹配的內(nèi)容經(jīng)過(guò) repl 處理后，替換 src 中的匹配項(xiàng)

// 如果 repl 的返回值中有“分組引用符”（$1、$name），則將“分組引用符”當(dāng)普通字符處理
// 全部替換，并返回替換后的結(jié)果
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 中搜索匹配項(xiàng)，并以匹配項(xiàng)為分割符，將 s 分割成多個(gè)子串

// 最多分割出 n 個(gè)子串，第 n 個(gè)子串不再進(jì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 中的“正則表達(dá)式”字符串

func (re *Regexp) String() string

func main() {
re := regexp.MustCompile("Hello.*$")
fmt.Printf("%s\n", re.String())
// Hello.*$
}

------------------------------------------------------------
45.返回 re 中的分組名稱(chēng)列表，未命名的分組返回空字符串

// 返回值[0] 為整個(gè)正則表達(dá)式的名稱(chēng)
// 返回值[1] 是分組 1 的名稱(chēng)
// 返回值[2] 是分組 2 的名稱(chēng)
// ……
func (re *Regexp) SubexpNames() []string

func main() {
re := regexp.MustCompile("(?PHello) (World)")
fmt.Printf("%q\n", re.SubexpNames())
// ["" "Name1" ""]
}
丰满人妻一级特黄a大片，午夜无码免费福利一级，欧美亚洲精品在线，国产婷婷成人久久Av免费高清