正则对象

正则使用都是通过创建对应的正则对象，调用对象方法所实现。

type Regexp struct {
    // 内含隐藏或非导出字段
}

新建正则对象

func Print(title string, data ...interface{}) {


    if len(data) == 1 {
        fmt.Printf("%s: %v \n", title, data[0])
        return
    }


    for i, v := range data {
        fmt.Printf("%s(%d): %v \n", title, i, v)
    }


}


// 新建正则对象
func CreateRegex() {

    r1, _ := regexp.Compile(`\w`)
    Print("r1", r1.MatchString("1d1d"))

    // POSIX ERE 语法
    r2, _ := regexp.CompilePOSIX(`[a-z]`)
    Print("r2", r2.MatchString("1234"))

    // 功能与Complie 相同，解析错误是抛出 panic
    r3 := regexp.MustCompile(`[1-9]`)
    Print("r3", r3.MatchString("13"))

    // 功能与CompilePOSIX 相同，解析错误是抛出 panic
    r4 := regexp.MustCompilePOSIX(`^_`)
    Print("r4", r4.MatchString("_prop"))

}

正则对象属性方法

// 属性方法
func Prop() {


    r1 := regexp.MustCompile(`^[a-z]`)


    // 获取正则字符串
    regStr := r1.String()
    Print("String", regStr)


    // 返回一个字符串字面值prefix
    prefix, complete := r1.LiteralPrefix()
    Print("LiteralPrefix", prefix, complete)


    // 捕获分组的数量
    // 正则分组名称规则 (?P<name>rgx)，注意这里为大写 P
    r2 := regexp.MustCompile(`(?P<number>[1-4]?) (?P<string>[a-z]?)`)
    groupNum := r2.NumSubexp()
    Print("NumSubexp", groupNum)


    // 获取分组名称
    groupNames := r2.SubexpNames()
    Print("SubexpNames", groupNames)


    // 使用 "leftmost-longest"模式
    r2.Longest()

正则方法

一般正则方法可以分为正对不同类型的三类方法

• []byte 针对字节输入，例如 Match
• string 针对字符输入， 例如 MathString
• reader 针对reader 接口 ，例如MatchReader

校验方法

func Match() {
    r1 := regexp.MustCompile(`[a-z]`)


    // 字节校验
    Print("Match", r1.Match([]byte("1f23c")))


    // 字符校验
    Print("MatchString", r1.MatchString("1f23c"))


    // reader 数据校验
    rd := bytes.NewReader([]byte("call me"))
    Print("MatchReader", r1.MatchReader(rd))

查询

查询分为两大类：

• 内容查询， 例如 Find
• 位置查询， 例如 FindIndex

func Find() {
    r1 := regexp.MustCompile(`[a-z]+`)


    // 字节查询
    Print("Find", r1.Find([]byte("1f23c")))


    // 字符查询
    Print("FindString", r1.FindString("1f23c"))


    // 获取匹配字节的起始位置, 左闭右开
    Print("FindIndex", r1.FindIndex([]byte("1f23c")))


    // 获取匹配字符的起始位置
    Print("FindStringIndex", r1.FindStringIndex("1f23c"))


    // 获取 reader 匹配数据的起始位置
    rd := bytes.NewReader([]byte("call me"))
    Print("FindReaderIndex", r1.FindReaderIndex(rd))


    r2 := regexp.MustCompile(`([a-z]+)([0-9]+)`)


    // 返回分组匹配的字节集切片
    Print("FindSubmatch", r2.FindSubmatch([]byte("1f23c")))


    // 返回分组匹配的字符切片
    Print("FindStringSubmatch", r2.FindStringSubmatch("1ff0ee"))


    // 返回分组匹配字节集位置切片
    Print("FindSubmatchIndex", r2.FindSubmatchIndex([]byte("1f23c")))


    // 返回分组匹配字符位置切片
    Print("FindStringSubmatchIndex", r2.FindStringSubmatchIndex("1ff0ee"))


    // 返回字节全匹配
    Print("FindAll", r1.FindAll([]byte("11ff0rr"), 2))


    // 字符全匹配
    Print("FindAllString", r1.FindAllString("11ff0rr", 2))


    // 返回全匹配字节位置
    Print("FindAllIndex", r1.FindAllIndex([]byte("11ff0rr"), 2))


    // 返回全匹配字符位置
    Print("FindAllStringIndex", r1.FindAllStringIndex("11ff0rr", 2))


    // 返回分组全匹配的字节集切片
    Print("FindAllSubmatch", r2.FindAllSubmatch([]byte("1f23c"), 10))


    // 返回分组全匹配的字符切片
    Print("FindAllStringSubmatch", r2.FindAllStringSubmatch("1ff0ee", 10))


    // 返回分组全匹配字节集位置切片
    Print("FindAllSubmatchIndex", r2.FindAllSubmatchIndex([]byte("1f23c"), 10))


    // 返回分组全匹配字符位置切片
    Print("FindAllStringSubmatchIndex", r2.FindAllStringSubmatchIndex("1ff0ee", 10))

分割

// 分割
func Split() {
    r1 := regexp.MustCompile(`0`)


    // 正则分割
    Print("Split", r1.Split("0f0r110l0", 3))  // 返回len = 3 切片，最后一个元素为剩余字符
    Print("Split", r1.Split("0f0r110l0", 0))  // 返回 nil
    Print("Split", r1.Split("0f0r110l0", -1)) // 全分割
}

追加

func Expand() {
    // 将模式匹配的字符拼接为模板，追加到字节集后
    r2 := regexp.MustCompile(`(?P<name>[a-z]+)(?P<age>[0-9]+)`)
    str1 := "jeck12"
    mt := r2.FindStringSubmatchIndex(str1)
    s := r2.ExpandString([]byte("man: "), "($name/$age)", str1, mt)
    Print("ExpandString", string(s))


    // ExpandString 字节版, 既输入内容类型不同
    s = r2.Expand([]byte("man: "), []byte("($name/$age)"), []byte(str1), mt)
    Print("Expand", string(s))

替换

func Replace() {


    // 非扩展替换
    r3 := regexp.MustCompile(`[a-z]+`)
    Print("ReplaceAllLiteral", r3.ReplaceAllLiteral([]byte("1fff"), []byte("z")))
    Print("ReplaceAllLiteralString", r3.ReplaceAllLiteralString("1fff", "z"))


    // 扩展替换
    r4 := regexp.MustCompile(`(?P<name>[a-z]+)(?P<age>[0-9]+)`)
    Print("ReplaceAll", r4.ReplaceAll([]byte("coco24,jeck12"), []byte("{name: $name, age: $age}")))
    Print("ReplaceAllString", r4.ReplaceAllString("coco24,jeck12", "{name: $name, age: $age}"))


    // 自定义替换
    r5 := regexp.MustCompile(`[a-z]+`)
    Print("ReplaceAllFunc", r5.ReplaceAllFunc([]byte("coco,jeck"), func(data []byte) []byte {
        fmt.Println(data)
        return []byte("oo")
    }))


    Print("ReplaceAllStringFunc", r5.ReplaceAllStringFunc("coco,jeck", func(data string) string {
        fmt.Println(data)
        return "00"
    }))

golang 标准库文档