Golang 정규 표현 식 (regexp)

6873 단어
Go 에 정규 표현 식 에 대한 지원 (regexp 패키지) 이 내장 되 어 있 습 니 다. 일반적인 정규 표현 식 일반적인 용법 의 예 입 니 다.
예시:
    package main

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

func main() {
    //       
    // .         ,*        ,      (  )
    match, _ := regexp.MatchString("H(.*)d!", "Hello World!")
    fmt.Println(match) //true
    // 
    match, _ = regexp.Match("H(.*)d!", []byte("Hello World!"))
    fmt.Println(match) //true
    //   `Compile`             
    r, _ := regexp.Compile("H(.*)d!")
    fmt.Println(r.MatchString("Hello World!")) //true

    //            
    fmt.Println(r.FindString("Hello World! world")) //Hello World!
    //  
    fmt.Println(string(r.Find([]byte("Hello World!")))) //Hello World!

    //               
    //           ,         
    fmt.Println(r.FindStringIndex("Hello World! world")) //[0 12]

    
    //                       ,           。
    //   r.FindAllStringSubmatch("Hello World! world",1)   。    
    //        `H(.*)d!`    
    //    `(.*)`    
    fmt.Println(r.FindStringSubmatch("Hello World! world")) //[Hello World! ello Worl]

    //         ,                
    //          
    fmt.Println(r.FindStringSubmatchIndex("Hello World! world")) //[0 12 1 10]
    //                ,       
    fmt.Println(r.FindAllString("Hello World! Held! world", -1)) //[Hello World! Held!]

    //                          ,       
    //      
    fmt.Println(r.FindAllStringSubmatchIndex("Hello World! world", -1))       //[[0 12 1 10]]
    fmt.Println(r.FindAllStringSubmatchIndex("Hello World! Held! world", -1)) //[[0 18 1 16]]

    //                      
    res, _ := regexp.Compile("H([a-z]+)d!")
    fmt.Println(res.FindAllString("Hello World! Held! Hellowrld! world", 2)) //[Held! Hellowrld!]

    fmt.Println(r.FindAllString("Hello World! Held! world", 2)) //[Hello World! Held!]
    //        ,               。

    // regexp                     
    fmt.Println(r.ReplaceAllString("Hello World! Held! world", "html")) //html world

    // `Func`                       
    //         
    in := []byte("Hello World! Held! world")
    out := r.ReplaceAllFunc(in, bytes.ToUpper)
    fmt.Println(string(out))

    //   b     reg           ,           
    // {    ,     }
    b := bytes.NewReader([]byte("Hello World!"))
    reg := regexp.MustCompile(`\w+`)
    fmt.Println(reg.FindReaderIndex(b)) //[0 5]

    //           r           ,          
    // {{    ,     }, {    ,     }, ...}
    //      n     ,   n < 0,        

    fmt.Println(r.FindAllIndex([]byte("Hello World!"), -1)) //[[0 12]]
    //  
    fmt.Println(r.FindAllStringIndex("Hello World!", -1)) //[[0 12]]

    //   s     re           ,          
    //              
    // {
    //     {     ,     ,     , ...},
    //     {     ,     ,     , ...},
    //     ...
    // }
    //      n     ,   n < 0,        
    reg = regexp.MustCompile(`(\w)(\w)+`)                      //[[Hello H o] [World W d]]
    fmt.Println(reg.FindAllStringSubmatch("Hello World!", -1)) //[[Hello H o] [World W d]]

    //   template         ,    dst    。
    // template     $1、$2、${name1}、${name2}    “     ”
    // match    FindSubmatchIndex        ,              
    //    template   “     ”,   match    ,
    //   src         ,    template    $1、$2      。
    reg = regexp.MustCompile(`(\w+),(\w+)`)
    src := []byte("Golang,World!")           //    
    dst := []byte("Say: ")                   //     
    template := []byte("Hello $1, Hello $2") //   
    m := reg.FindSubmatchIndex(src)          //      
    //     ,            
    fmt.Printf("%q", reg.Expand(dst, template, src, m))
    // "Say: Hello Golang, Hello World"

    // LiteralPrefix                (      )
    // prefix:       
    // complete:   prefix          ,    true,     false
    reg = regexp.MustCompile(`Hello[\w\s]+`)
    fmt.Println(reg.LiteralPrefix())
    // Hello false
    reg = regexp.MustCompile(`Hello`)
    fmt.Println(reg.LiteralPrefix())
    // Hello true

    text := `Hello World! hello world`
    //     “     ”(?U)
    reg = regexp.MustCompile(`(?U)H[\w\s]+o`)
    fmt.Printf("%q
", reg.FindString(text)) // Hello // “ ” reg.Longest() fmt.Printf("%q
", reg.FindString(text)) // Hello Wo // ( “ ”) fmt.Println(r.NumSubexp()) //1 // r “ ” fmt.Printf("%s
", r.String()) // , , // n , n // n < 0, // fmt.Printf("%q
", r.Split("Hello World! Helld! hello", -1)) //["" " hello"] // , repl // rep “ ”($1、$name), “ ” // , s := "Hello World, hello!" reg = regexp.MustCompile(`(Hell|h)o`) rep := "${1}" fmt.Printf("%q
", reg.ReplaceAllLiteralString(s, rep)) //"${1} World, hello!" // , repl , // repb “ ”($1、$name), “ ” // , ss := []byte("Hello World!") reg = regexp.MustCompile("(H)ello") repb := []byte("$0$1") fmt.Printf("%s
", reg.ReplaceAll(ss, repb)) // HelloH World! fmt.Printf("%s
", reg.ReplaceAllFunc(ss, func(b []byte) []byte { rst := []byte{} rst = append(rst, b...) rst = append(rst, "$1"...) return rst })) // Hello$1 World! }

소결:
1、
r, _ := regexp.Compile("H(.*)d!")

대체 할 수 있다
r := regexp.MustCompile("H(.*)d!")

두 가지 차이 MustCompile 에 반환 값 이 하나 부족 합 니 다 err
원본 코드 를 보다
// Compile parses a regular expression and returns, if successful,
// a Regexp object that can be used to match against text.
//...
// For POSIX leftmost-longest matching, see CompilePOSIX.
func Compile(expr string) (*Regexp, error) {
    return compile(expr, syntax.Perl, false)
}

// MustCompile is like Compile but panics if the expression cannot be parsed.
// It simplifies safe initialization of global variables holding compiled regular
// expressions.
func MustCompile(str string) *Regexp {
   regexp, err := Compile(str)
   if err != nil {
      panic(`regexp: Compile(` + quote(str) + `): ` + err.Error())
   }
   return regexp
}

2. regexp 의 처리 byte 방법 은 모두 string 방법 으로 대응 되 는데 이들 의 기능 은 같다.
예 를 들 면:
regexp.Match()
 
regexp.MatchString()

links
목록

좋은 웹페이지 즐겨찾기