go regexp 正则表达式使用

• go 正则表达式使用：

/**
* @Author: wsp
* @Date: 2018/1/15 10:58
* @Description:
 */
package regexpStudy

import (
    "bytes"
    "fmt"
    "regexp"
)

func RegexpStudy1() {
    var result interface{}
    var err error
    result, err = regexp.MatchString("w[0-9]*sp", "wsp")
    ErrHandler(err)
    fmt.Println("匹配结果：", result)
}

func RegexpStudy2() {
    r, err := regexp.Compile("u([a-z]+)ledger")
    ErrHandler(err)
    // 判断是否匹配
    fmt.Println(r.MatchString("uniledger"))

    // 匹配第一次出现的字符串
    fmt.Println(r.FindString("uniledger uwspledger"))

    // 匹配第一次出现的字符串开始及结束索引
    fmt.Println(r.FindStringIndex("uniledger uwspledger"))

    // 返回第一次匹配的字符串，全局匹配及局部匹配的内容
    fmt.Println(r.FindStringSubmatch("uniledger uwspledger"))

    // 返回第一次匹配的字符串，全局匹配及局部匹配的内容的开始及结束的索引
    fmt.Println(r.FindStringSubmatchIndex("uniledger uwspledger"))

    // 返回字符串所有匹配的内容，不仅仅首次匹配项 n<0 返回所有匹配项，n>0 返回n个匹配项
    fmt.Println(r.FindAllString("uniledger uwspledger uniledger uwspledger", -1))

    // 返回字符串所有匹配的内容，不仅仅首次匹配项 n<0 返回所有匹配项，n>0 返回n个匹配项的索引
    fmt.Println(r.FindAllStringIndex("uniledger uwspledger uniledger uwspledger", -1))

    // 返回[]byte数组所有匹配的内容，不仅仅首次匹配项 n<0 返回所有匹配项，n>0 返回n个匹配项的索引
    fmt.Println(r.FindAllIndex([]byte("uniledger uwspledger uniledger uwspledger"), -1))

    r = regexp.MustCompile("p([a-z]+)ch")
    fmt.Println(r)

    // 替换匹配的字符串的内容
    fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))

    // 将匹配的元素 传递给一个函数
    in := []byte("a peach")
    out := r.ReplaceAllFunc(in, bytes.ToUpper)
    fmt.Println(string(out))

}

/**
* @Author: wsp
* @Date: 10:27 2018/1/12
* @Description: 错误处理
 */
func ErrHandler(err error) {
    if err != nil {
        panic(err)
    }
}

• 测试文件

/**
* @Author: wsp
* @Date: 2018/1/15 10:58
* @Description:
 */
package regexpStudy

import "testing"

func TestRegexpStudy1(t *testing.T) {
    RegexpStudy1()
}

func TestRegexpStudy2(t *testing.T) {
    RegexpStudy2()
}

• 测试结果

true
punch
[0 5]
[punch un]
[0 5 1 3]
[peach punch pinch]
[[0 5] [6 11] [12 17]]
[[0 5] [6 11] [12 17]]
p([a-z]+)ch
a <fruit>
a PEACH