GoRegexregexp樣本大全

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

// 判斷在 b 中能否找到Regex pattern 所匹配的子串// pattern：要尋找的Regex// b：要在其中進行尋找的 []byte// matched：返回是否找到匹配項// err：返回尋找過程中遇到的任何錯誤// 此函數通過調用 Regexp 的方法實現func Match(pattern string, b []byte) (matched bool, err error) func main() {fmt.Println(regexp.Match("H.* ", []byte("Hello World!")))// true }

// 判斷在 r 中能否找到Regex pattern 所匹配的子串// pattern：要尋找的Regex// r：要在其中進行尋找的 RuneReader 介面// matched：返回是否找到匹配項// 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 }

// 判斷在 s 中能否找到Regex pattern 所匹配的子串// pattern：要尋找的Regex// r：要在其中進行尋找的字串// matched：返回是否找到匹配項// err：返回尋找過程中遇到的任何錯誤// 此函數通過調用 Regexp 的方法實現func MatchString(pattern string, s string) (matched bool, err error) func main() {fmt.Println(regexp.Match("H.* ", "Hello World!"))// true }

// QuoteMeta 將字串 s 中的“特殊字元”轉換為其“轉義格式”// 例如，QuoteMeta（`[foo]`）返回`\[foo\]`。// 特殊字元有：\.+*?()|[]{}^$// 這些字元用於實現正則文法，所以當作一般字元使用時需要轉換func QuoteMeta(s string) string func main() {fmt.Println(regexp.QuoteMeta("(?P:Hello) [a-z]"))// \(\?P:Hello\) \[a-z\]}

// Regexp 結構表示一個編譯後的Regex// Regexp 的公開介面都是通過方法實現的// 多個 goroutine 並發使用一個 RegExp 是安全的type Regexp struct {// 私人欄位} // 通過 Complite、CompilePOSIX、MustCompile、MustCompilePOSIX // 四個函數可以建立一個 Regexp 對象

// Compile 用來解析Regex 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",}

// CompilePOSIX 的作用和 Compile 一樣// 不同的是，CompilePOSIX 使用 POSIX 文法，// 同時，它採用最左最長方式搜尋，// 而 Compile 採用最左最短方式搜尋// POSIX 文法不支援 Perl 的文法格式：\d、\D、\s、\S、\w、\Wfunc CompilePOSIX(expr string) (*Regexp, error) func main() {reg, err := regexp.CompilePOSIX(`[[:word:]]+`)fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)// "Hello"}

// MustCompile 的作用和 Compile 一樣// 不同的是，當Regex str 不合法時，MustCompile 會拋出異常// 而 Compile 僅返回一個 error 值func MustCompile(str string) *Regexp func main() {reg := regexp.MustCompile(`\w+`)fmt.Println(reg.FindString("Hello World!"))// Hello}

// MustCompilePOSIX 的作用和 CompilePOSIX 一樣// 不同的是，當Regex str 不合法時，MustCompilePOSIX 會拋出異常// 而 CompilePOSIX 僅返回一個 error 值func MustCompilePOSIX(str string) *Regexp func main() {reg := regexp.MustCompilePOSIX(`[[:word:]].+ `)fmt.Printf("%q\n", reg.FindString("Hello World!"))// "Hello "}

// 在 b 中尋找 re 中編譯好的Regex，並返回第一個匹配的內容func (re *Regexp) Find(b []byte) []byte func main() {reg := regexp.MustCompile(`\w+`)fmt.Printf("%q", reg.Find([]byte("Hello World!")))// "Hello"}// 在 s 中尋找 re 中編譯好的Regex，並返回第一個匹配的內容func (re *Regexp) FindString(s string) stringfunc main() {reg := regexp.MustCompile(`\w+`)fmt.Println(reg.FindString("Hello World!"))// "Hello"}

// 在 s 中尋找 re 中編譯好的Regex，並返回第一個匹配的內容func (re *Regexp) FindString(s string) string func main() {reg := regexp.MustCompile(`\w+`)fmt.Println(reg.FindString("Hello World!"))// "Hello"}

// 在 b 中尋找 re 中編譯好的Regex，並返回所有匹配的內容// {{匹配項}, {匹配項}, ...}// 只尋找前 n 個匹配項，如果 n < 0，則尋找所有匹配項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"]}

// 在 s 中尋找 re 中編譯好的Regex，並返回所有匹配的內容// {匹配項, 匹配項, ...}// 只尋找前 n 個匹配項，如果 n < 0，則尋找所有匹配項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"]}

// 在 b 中尋找 re 中編譯好的Regex，並返回第一個匹配的位置// {起始位置, 結束位置}func (re *Regexp) FindIndex(b []byte) (loc []int) func main() {reg := regexp.MustCompile(`\w+`)fmt.Println(reg.FindIndex([]byte("Hello World!")))// [0 5]}

// 在 s 中尋找 re 中編譯好的Regex，並返回第一個匹配的位置// {起始位置, 結束位置}func (re *Regexp) FindStringIndex(s string) (loc []int) func main() {reg := regexp.MustCompile(`\w+`)fmt.Println(reg.FindStringIndex("Hello World!"))// [0 5]}

// 在 r 中尋找 re 中編譯好的Regex，並返回第一個匹配的位置// {起始位置, 結束位置}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]}

// 在 b 中尋找 re 中編譯好的Regex，並返回所有匹配的位置// {{起始位置, 結束位置}, {起始位置, 結束位置}, ...}// 只尋找前 n 個匹配項，如果 n < 0，則尋找所有匹配項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]]}

// 在 s 中尋找 re 中編譯好的Regex，並返回所有匹配的位置// {{起始位置, 結束位置}, {起始位置, 結束位置}, ...}// 只尋找前 n 個匹配項，如果 n < 0，則尋找所有匹配項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]]}

// 在 b 中尋找 re 中編譯好的Regex，並返回第一個匹配的內容// 同時返回子運算式匹配的內容// {{完整匹配項}, {子匹配項}, {子匹配項}, ...}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"]}

// 在 s 中尋找 re 中編譯好的Regex，並返回第一個匹配的內容// 同時返回子運算式匹配的內容// {完整匹配項, 子匹配項, 子匹配項, ...}func (re *Regexp) FindStringSubmatch(s string) []string func main() {reg := regexp.MustCompile(`(\w)(\w)+`)fmt.Printf("%q", reg.FindStringSubmatch("Hello World!"))// ["Hello" "H" "o"]}

// 在 b 中尋找 re 中編譯好的Regex，並返回所有匹配的內容// 同時返回子運算式匹配的內容// {//     {{完整匹配項}, {子匹配項}, {子匹配項}, ...},//     {{完整匹配項}, {子匹配項}, {子匹配項}, ...},//     ...// }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"]]}

// 在 s 中尋找 re 中編譯好的Regex，並返回所有匹配的內容// 同時返回子運算式匹配的內容// {//     {完整匹配項, 子匹配項, 子匹配項, ...},//     {完整匹配項, 子匹配項, 子匹配項, ...},//     ...// }// 只尋找前 n 個匹配項，如果 n < 0，則尋找所有匹配項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"]]}

// 在 b 中尋找 re 中編譯好的Regex，並返回第一個匹配的位置// 同時返回子運算式匹配的位置// {完整項起始, 完整項結束, 子項起始, 子項結束, 子項起始, 子項結束, ...}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]}

// 在 s 中尋找 re 中編譯好的Regex，並返回第一個匹配的位置// 同時返回子運算式匹配的位置// {完整項起始, 完整項結束, 子項起始, 子項結束, 子項起始, 子項結束, ...}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]}

// 在 r 中尋找 re 中編譯好的Regex，並返回第一個匹配的位置// 同時返回子運算式匹配的位置// {完整項起始, 完整項結束, 子項起始, 子項結束, 子項起始, 子項結束, ...}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]}

// 在 b 中尋找 re 中編譯好的Regex，並返回所有匹配的位置// 同時返回子運算式匹配的位置// {//     {完整項起始, 完整項結束, 子項起始, 子項結束, 子項起始, 子項結束, ...}, //     {完整項起始, 完整項結束, 子項起始, 子項結束, 子項起始, 子項結束, ...}, //     ...// }// 只尋找前 n 個匹配項，如果 n < 0，則尋找所有匹配項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]]}

// 在 s 中尋找 re 中編譯好的Regex，並返回所有匹配的位置// 同時返回子運算式匹配的位置// {//     {完整項起始, 完整項結束, 子項起始, 子項結束, 子項起始, 子項結束, ...}, //     {完整項起始, 完整項結束, 子項起始, 子項結束, 子項起始, 子項結束, ...}, //     ...// }// 只尋找前 n 個匹配項，如果 n < 0，則尋找所有匹配項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]]}

// 將 template 的內容經過處理後，追加到 dst 的尾部。// template 中要有 $1、$2、${name1}、${name2} 這樣的“分組引用符”// match 是由 FindSubmatchIndex 方法返回的結果，裡面存放了各個分組的位置資訊// 如果 template 中有“分組引用符”，則以 match 為標準，// 在 src 中取出相應的子串，替換掉 template 中的 $1、$2 等引用符號。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: ")                   // 目標文本template := []byte("Hello $1, Hello $2") // 模板match := reg.FindSubmatchIndex(src)      // 解析源文本// 填寫模板，並將模板追加到目標文本中fmt.Printf("%q", reg.Expand(dst, template, src, match))// "Say: Hello Golang, Hello World"}

// 功能同 Expand 一樣，只不過參數換成了 string 類型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: ")                    // 目標文本（可寫）template := "Hello $1, Hello $2"          // 模板match := reg.FindStringSubmatchIndex(src) // 解析源文本// 填寫模板，並將模板追加到目標文本中fmt.Printf("%q", reg.ExpandString(dst, template, src, match))// "Say: Hello Golang, Hello World"}

// LiteralPrefix 返回所有匹配項都共同擁有的首碼（去除可變元素）// prefix：共同擁有的首碼// complete：如果 prefix 就是Regex本身，則返回 true，否則返回 falsefunc (re *Regexp) LiteralPrefix() (prefix string, complete bool) func main() {reg := regexp.MustCompile(`Hello[\w\s]+`)fmt.Println(reg.LiteralPrefix())// Hello falsereg = regexp.MustCompile(`Hello`)fmt.Println(reg.LiteralPrefix())// Hello true}

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

// 判斷在 b 中能否找到匹配項func (re *Regexp) Match(b []byte) bool func main() {b := []byte(`Hello World`)reg := regexp.MustCompile(`Hello\w+`)fmt.Println(reg.Match(b))// falsereg = regexp.MustCompile(`Hello[\w\s]+`)fmt.Println(reg.Match(b))// true}

// 判斷在 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))// falser.Seek(0, 0)reg = regexp.MustCompile(`Hello[\w\s]+`)fmt.Println(reg.MatchReader(r))// true}

// 判斷在 s 中能否找到匹配項func (re *Regexp) MatchString(s string) bool func main() {s := `Hello World`reg := regexp.MustCompile(`Hello\w+`)fmt.Println(reg.MatchString(s))// falsereg = regexp.MustCompile(`Hello[\w\s]+`)fmt.Println(reg.MatchString(s))// true}

// 統計Regex中的分組個數（不包括“非捕獲的分組”）func (re *Regexp) NumSubexp() int func main() {reg := regexp.MustCompile(`(?U)(?:Hello)(\s+)(\w+)`)fmt.Println(reg.NumSubexp())// 2}

// 在 src 中搜尋匹配項，並替換為 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!"}

// 在 src 中搜尋匹配項，並替換為 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!"}

// 在 src 中搜尋匹配項，並替換為 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!"}

// 在 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!"}

// 在 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!}

// 在 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!}

// 在 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"]}

// 返回 re 中的“Regex”字串func (re *Regexp) String() string func main() {re := regexp.MustCompile("Hello.*$")fmt.Printf("%s\n", re.String())// Hello.*$}

// 返回 re 中的分組名稱列表，未命名的分組返回Null 字元串// 傳回值[0] 為整個Regex的名稱// 傳回值[1] 是分組 1 的名稱// 傳回值[2] 是分組 2 的名稱// ……func (re *Regexp) SubexpNames() []string func main() {re := regexp.MustCompile("(?PHello) (World)")fmt.Printf("%q\n", re.SubexpNames())// ["" "Name1" ""]}