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