1) 字符

    语法 说明 表达式示例 匹配结果
    一般字符 匹配自身 abc abc
    . 匹配任意除换行符”\n”外的字符， 在 DOTALL 模式中也能匹配换行符 a.c abc
    \ 转义字符，使后一个字符改变原来的意思；
    如果字符串中有字符 需要匹配，可以使用 \ 或者字符集［*]。    		 a\.c
    a\\c    		 a.c
    a\c
    […] 字符集（字符类），对应的位置可以是字符集中任意字符。
    字符集中的字符可以逐个列出，也可以给出范围，如 [abc] 或 [a-c]，
    第一个字符如果是 ^ 则表示取反，如 [^abc] 表示除了abc之外的其他字符。    		 a[bcd]e abe 或 ace 或 ade
    \d 数字：[0-9] a\dc a1c
    \D 非数字：[^\d] a\Dc abc
    \s 空白字符：[<空格>\t\r\n\f\v] a\sc a c
    \S 非空白字符：[^\s] a\Sc abc
    \w 单词字符：[A-Za-z0-9] a\wc abc
    \W 非单词字符：[^\w] a\Wc a c

    2) 数量词（用在字符或 (…) 之后）

    语法 说明 表达式示例 匹配结果
    * 匹配前一个字符 0 或无限次 abc* ab 或 abccc
    + 匹配前一个字符 1 次或无限次 abc+ abc 或 abccc
    ? 匹配前一个字符 0 次或 1 次 abc? ab 或 abc
    {m} 匹配前一个字符 m 次 ab{2}c abbc
    {m,n} 匹配前一个字符 m 至 n 次，m 和 n 可以省略，若省略 m，则匹配 0 至 n 次；
    若省略 n，则匹配 m 至无限次    		 ab{1,2}c abc 或 abbc

    3) 边界匹配

    语法 说明 表达式示例 匹配结果
    ^ 匹配字符串开头，在多行模式中匹配每一行的开头 ^abc abc
    $ 匹配字符串末尾，在多行模式中匹配每一行的末尾 abc$ abc
    \A 仅匹配字符串开头 \Aabc abc
    \Z 仅匹配字符串末尾 abc\Z abc
    \b 匹配 \w 和 \W 之间 a\b!bc a!bc
    \B [^\b] a\Bbc abc

    4) 逻辑、分组

    语法 说明 表达式示例 匹配结果
    | | 代表左右表达式任意匹配一个，优先匹配左边的表达式 abc|def abc 或 def
    (…) 括起来的表达式将作为分组，分组将作为一个整体，可以后接数量词 (abc){2} abcabc
    (?P…) 分组，功能与 (…) 相同，但会指定一个额外的别名 (?Pabc){2} abcabc
    \ 引用编号为 的分组匹配到的字符串 (\d)abc\1 1abe1 或 5abc5
    (?P=name) 引用别名为 的分组匹配到的字符串 (?P\d)abc(?P=id) 1abe1 或 5abc5

    5) 特殊构造（不作为分组）

    语法 说明 表达式示例 匹配结果
    (?:…) (…) 的不分组版本，用于使用 “|” 或后接数量词 (?:abc){2} abcabc
    (?iLmsux) iLmsux 中的每个字符代表一种匹配模式，只能用在正则表达式的开头，可选多个 (?i)abc AbC
    (?#…) # 后的内容将作为注释被忽略。 abc(?#comment)123 abc123
    (?=…) 之后的字符串内容需要匹配表达式才能成功匹配 a(?=\d) 后面是数字的 a
    (?!…) 之后的字符串内容需要不匹配表达式才能成功匹配 a(?!\d) 后面不是数字的 a
    (?<=…) 之前的字符串内容需要匹配表达式才能成功匹配 (?<=\d)a 前面是数字的a
    (?<!…) 之前的字符串内容需要不匹配表达式才能成功匹配 (?<!\d)a 前面不是数字的a 
    1. package main
    3. import (
    4.    "bytes"
    5.    "fmt"
    6.    "regexp"
    7. )
    9. func main() {
    11.    // func Match(pattern string, b []byte) (matched bool, err error)
    12.    // 判断在 b 中能否找到正则表达式 pattern 所匹配的子串
    13.    match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
    14.    fmt.Println(match) // true
    16.    // 也可以这样编译后使用
    17.    r, _ := regexp.Compile("p([a-z]+)ch")
    18.    fmt.Println(r.MatchString("peach")) // true
    20.    // func (re *Regexp) FindString(s string) string
    21.    // 在 s 中查找 re 中编译好的正则表达式，并返回第一个匹配的内容
    22.    fmt.Println(r.FindString("peach punch")) // peach
    24.    // func (re *Regexp) FindStringIndex(s string) (loc []int)
    25.    // 在 s 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置
    26.    // {起始位置, 结束位置}
    27.    fmt.Println(r.FindStringIndex("peach punch")) // [0 5]
    29.    // func (re *Regexp) FindStringSubmatch(s string) []string
    30.    // 在 s 中查找 re 中编译好的正则表达式，并返回第一个匹配的内容
    31.    // 同时返回子表达式匹配的内容
    32.    // {完整匹配项, 子匹配项, 子匹配项, ...}
    33.    fmt.Println(r.FindStringSubmatch("peach punch")) // [peach ea]
    35.    // func (re *Regexp) FindStringSubmatchIndex(s string) []int
    36.    // 在 s 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置
    37.    // 同时返回子表达式匹配的位置
    38.    // {完整项起始, 完整项结束, 子项起始, 子项结束, 子项起始, 子项结束, ...}
    39.    fmt.Println(r.FindStringSubmatchIndex("peach punch")) // [0 5 1 3]
    41.    //func (re *Regexp) FindAllString(s string, n int) []string
    42.    // 在 s 中查找 re 中编译好的正则表达式，并返回所有匹配的内容
    43.    // {匹配项, 匹配项, ...}
    44.    // 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
    45.    fmt.Println(r.FindAllString("peach punch pinch", -1))
    46.    // [peach punch pinch]
    47.    fmt.Println(r.FindAllString("peach punch pinch", 2))
    48.    // [peach punch]
    50.    // func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
    51.    // 在 s 中查找 re 中编译好的正则表达式，并返回所有匹配的位置
    52.    // 同时返回子表达式匹配的位置
    53.    // {
    54.    //     {完整项起始, 完整项结束, 子项起始, 子项结束, 子项起始, 子项结束, ...},
    55.    //     {完整项起始, 完整项结束, 子项起始, 子项结束, 子项起始, 子项结束, ...},
    56.    //     ...
    57.    // }
    58.    // 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
    59.    fmt.Println(r.FindAllStringSubmatchIndex(
    60.       "peach punch pinch", -1))
    61.    // [[0 5 1 3] [6 11 7 9] [12 17 13 15]]
    63.    // func (re *Regexp) Match(b []byte) bool
    64.    // 判断在 b 中能否找到匹配项
    65.    fmt.Println(r.Match([]byte("peach"))) //true
    67.    // func MustCompile(str string) *Regexp
    68.    // MustCompile 的作用和 Compile 一样
    69.    // 不同的是，当正则表达式 str 不合法时，MustCompile 会抛出异常
    70.    // 而 Compile 仅返回一个 error 值
    71.    r = regexp.MustCompile("p([a-z]+)ch")
    72.    fmt.Println(r) // p([a-z]+)ch
    74.    // func (re *Regexp) ReplaceAllString(src, repl string) string
    75.    // 在 src 中搜索匹配项，并替换为 repl 指定的内容
    76.    // 全部替换，并返回替换后的结果
    77.    fmt.Println(r.ReplaceAllString("a peach", "<fruit>")) // a <fruit>
    79.    // func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
    80.    // 在 src 中搜索匹配项，然后将匹配的内容经过 repl 处理后，替换 src 中的匹配项
    81.    // 如果 repl 的返回值中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
    82.    // 全部替换，并返回替换后的结果
    83.    in := []byte("a peach")
    84.    out := r.ReplaceAllFunc(in, bytes.ToUpper)
    85.    fmt.Println(string(out)) // a PEACH
    86. }