go语言使用正则表达式

Go语言通过regexp标准库提供了强大的正则表达式功能。下面介绍如何在Go中使用正则表达式：

基本用法

1. 编译正则表达式

import "regexp"

func main() {
    // 编译正则表达式
    re := regexp.MustCompile(`\d+`) // 匹配一个或多个数字
    
    // 或者使用regexp.Compile，它返回两个值(正则表达式, 错误)
    re, err := regexp.Compile(`\d+`)
    if err != nil {
        panic(err)
    }
}

2. 简单匹配

func main() {
    re := regexp.MustCompile(`go`)
    
    // 检查字符串中是否包含匹配
    fmt.Println(re.MatchString("hello go")) // true
    fmt.Println(re.MatchString("hello world")) // false
}

常用方法

1. 查找匹配

func main() {
    re := regexp.MustCompile(`\d+`)
    
    // 查找第一个匹配
    fmt.Println(re.FindString("abc 123 def 456")) // "123"
    
    // 查找所有匹配
    fmt.Println(re.FindAllString("abc 123 def 456", -1)) // ["123" "456"]
    
    // 查找匹配的索引位置
    fmt.Println(re.FindStringIndex("abc 123 def 456")) // [4 7]
}

2. 替换匹配

func main() {
    re := regexp.MustCompile(`\d+`)
    
    // 替换第一个匹配
    fmt.Println(re.ReplaceAllString("abc 123 def 456", "X")) // "abc X def 456"
    
    // 替换所有匹配
    fmt.Println(re.ReplaceAllString("abc 123 def 456", "X")) // "abc X def X"
    
    // 使用函数进行替换
    fmt.Println(re.ReplaceAllStringFunc("abc 123 def 456", func(s string) string {
        return strings.Repeat("*", len(s))
    })) // "abc *** def ***"
}

3. 分组捕获

func main() {
    re := regexp.MustCompile(`(\d+)-(\w+)`)
    
    // 查找子匹配
    matches := re.FindStringSubmatch("id: 123-go")
    fmt.Println(matches) // ["123-go" "123" "go"]
    
    // 查找所有子匹配
    allMatches := re.FindAllStringSubmatch("id: 123-go, 456-rust", -1)
    for _, m := range allMatches {
        fmt.Println(m)
    }
    // ["123-go" "123" "go"]
    // ["456-rust" "456" "rust"]
}

高级用法

1. 使用正则表达式对象

func main() {
    re := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`)
    
    // 使用命名捕获组
    matches := re.FindStringSubmatch("2023-05-15")
    for i, name := range re.SubexpNames() {
        if i != 0 && name != "" {
            fmt.Printf("%s: %s\n", name, matches[i])
        }
    }
    // year: 2023
    // month: 05
    // day: 15
}

2. 性能优化

对于频繁使用的正则表达式，应该预编译：

var (
    emailRe = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
)

func isValidEmail(email string) bool {
    return emailRe.MatchString(email)
}

3. 分割字符串

func main() {
    re := regexp.MustCompile(`\s+`)
    words := re.Split("hello   world\tgo", -1)
    fmt.Println(words) // ["hello" "world" "go"]
}

注意事项

1. Go的正则表达式实现是RE2，它不支持一些高级特性如回溯引用
2. 正则表达式编译是相对昂贵的操作，应该重用编译好的正则表达式对象
3. 对于复杂的文本处理，正则表达式可能不是最高效的解决方案
4. 注意正则表达式的性能，避免灾难性回溯

示例：解析日志

func main() {
    logLine := `127.0.0.1 - - [15/May/2023:10:30:22 +0800] "GET /api/users HTTP/1.1" 200 1234`
    
    re := regexp.MustCompile(`^(\S+) \S+ \S+ \[([^\]]+)\] "([^"]+)" (\d+) (\d+)`)
    
    matches := re.FindStringSubmatch(logLine)
    if len(matches) != 6 {
        fmt.Println("Invalid log format")
        return
    }
    
    fmt.Println("IP:", matches[1])
    fmt.Println("Timestamp:", matches[2])
    fmt.Println("Request:", matches[3])
    fmt.Println("Status:", matches[4])
    fmt.Println("Bytes:", matches[5])
}

通过掌握这些正则表达式用法，你可以在Go中高效地处理各种文本匹配和解析任务。