go regexp 正则包练习

package main  
/* 练习 regexp 包的使用 */
/* 里面的函数有点多，而且挺复杂的 ，之挑几个重要的说一下啊 */
import (
    "fmt"
    "regexp"
)


// 小试牛刀: 第一个例子
// 匹配指定类型的字符串
func common_regx(){

    str := "abcde  sbm"
    regx := regexp.MustCompile(`c.e`)
    if regx == nil{
        fmt.Printf("REGX COMPILE ERROR")
        return 
    }
    result := regx.FindAllStringSubmatch(str, -1)
    fmt.Printf("匹配到结果是 %v", result[0][0])
}

// Match  func Match(pattern string, b []byte) (matched bool, err error)
// slice b 是不是有匹配pattern  并不是py开头匹配的意思
func match(){
    is_match, err := regexp.Match("a.c", []byte("ccabcd,sb"))
    fmt.Printf("是不是匹配了 %v, 错误：%v", is_match, err)
    // > 是不是匹配了 true, 错误：<nil>
}


// MatchString  func MatchString(pattern string, s string) (matched bool, err error)
func match_string(){
    // 和 Match 不同的是，第二个参数是 string 而不是 byte 切片
    is_match, err := regexp.MatchString("(?i)ab.", "CCABCD, SBM")  // (?i) 是模式匹配的一种， py 里以已经看过了 
    fmt.Printf("%v, %v", is_match, err)
    // > true, <nil>

}

//  Regexp  
func regexp_struct(){
    // 这个暂时不知到撒意思？


}


// Compile func Compile(expr string) (*Regexp, error)
func compile(){
    // 这个也不太懂？


}

// MustCompile  func MustCompile(str string) *Regexp

func must_compile(){
    // 基本同Compile, 编译不成功好像是直接 panic

}

//  Copy func (re *Regexp) Copy() *Regexp
func copy(){
    // 拷贝一个 Regexp 对象，深copy

}

// Find  func (re *Regexp) Find(b []byte) []byte
func find(){
    // 返回左边的匹配结果
    regx := regexp.MustCompile(`SBM.?`)
    fmt.Printf("%c", regx.Find([]byte("aSBMN, SBMM")))
    // > "SBMN"   %c => [S B M N]

}

// FindAll  func (re *Regexp) FindAll(b []byte, n int) [][]byte
func findall(){
    // 返回 find 的切片组合
    regx := regexp.MustCompile(`SBM.?`)
    fmt.Printf("%q", regx.FindAll([]byte("aSBMN, SBMM"), -1))  // -1 只要小于0 ，就返回所有结果， >=0 则尽可能返回 这个数量的结果

    //> ["SBMN" "SBMM"]
}


// FindAllIndex   func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
func FindAllIndex(){
    // 基本同 FindAll ,只不过 他返回的是索引位置
    content := []byte("London")
    re := regexp.MustCompile(`o.`)
    fmt.Println(re.FindAllIndex(content, 1))  // 1 的位置含义同 FindAll
    fmt.Println(re.FindAllIndex(content, -1))

    // > [[1 3]]
    //   [[1 3] [4 6]]

}


// FindAllString  func (re *Regexp) FindAllString(s string, n int) []string
func find_all_string(){
    // 同 FindAll , 只不过参数和返回值是 字符串而不是数组了
    regx := regexp.MustCompile("abc")
    fmt.Printf("%v", regx.FindAllString("abcfdfabc", -1))
    // > [abc abc]

}

// FindAllStringIndex  func (re *Regexp) FindAllStringIndex(s string, n int) [][]int
func find_all_string_index(){
    // 同 FindAllIndex 只不过参数是字符串，而不是 byte 数组了
    regx := regexp.MustCompile("abc")
    fmt.Printf("%v", regx.FindAllStringIndex("abcfdfabc", -1))
}

// FindIndex  func (re *Regexp) FindIndex(b []byte) (loc []int)
func find_index(){
    // FindAllIndex  单个匹配模式。
    // 参数是byte 切片哦。 找到第一个匹配的索引 开头：结尾 的一个切片
    regx := regexp.MustCompile("ab.")
    fmt.Printf("%v", regx.FindIndex([]byte ("abcdfdabc"))) 
    // > [0 3]
}


// FindString  func (re *Regexp) FindString(s string) string
func find_string(){
    // 类似 FindAllString  只不过只是 返回第一个匹配的 字符串

}

// FindStringIndex  func (re *Regexp) FindStringIndex(s string) (loc []int)
func find_string_index(){
    // 基本同 FindIndex 这里针对字符串


} 

// ReplaceAll  func (re *Regexp) ReplaceAll(src, repl []byte) []byte
func replace_all(){
    // 不会
}

// Split  func (re *Regexp) Split(s string, n int) []string
func split(){
    // 就是分割成 字符串的切片
    
}


func main(){
    // common_regx()
    // match()
    // match_string()
    // findall()
    // find_all_string()
    // find_all_string_index()
    find_index()

}

简单总结一下：
Find(All)?(String)?(Submatch)?(Index)? 这样记

All 表示获取所有匹配结果，带有 All 的方法，会有第二个参数num int, num >=0 尽可能返回前num个匹配结果， <0 返回所有结果
String 表示参数是字符串，没有String 的参数默认是字节数组 []byte
Submatch 表示捕获分组，返回的是切片从左到右按左括号的顺序编号。 0为完整匹配的字串， 1 为第一个左 ( 的匹配的东西。
Index 表示返回匹配的索引号

go regexp 正则包 练习

go regexp 正则包练习