Go-11-正则表达式与字符串高级处理

2026-08-22

字数统计: 1.7k字 | 阅读时长≈ 8分

Go-11-正则表达式与字符串高级处理

本节目标：掌握 Go 的 regexp 包，能写日志分析、URL 解析、表单验证等常见正则任务。

1. regexp 包基础

Go 的正则引擎是 RE2（不是 PCRE），保证线性时间且没有灾难性回溯。

import "regexp"

// 编译正则（推荐预编译，不要每次 MatchString 时编译）
re := regexp.MustCompile(`\d+`)

// 三个核心方法
re.MatchString("abc123")     // true
re.FindString("abc123def")   // "123"
re.FindAllString("a1b22c333", -1)  // ["1" "22" "333"]

编译错误：

re, err := regexp.Compile(`\d+`)  // 错误用 Compile，返回 error
if err != nil {
    log.Fatal(err)
}

re := regexp.MustCompile(`[`)     // MustCompile 错误会 panic，适合常量正则

2. 常用操作

2.1 Match：是否匹配

1 2	re := regexp.MustCompile(`^1[3-9]\d{9}$`) fmt.Println(re.MatchString("13800138000")) // true（手机号）

2.2 Find：查找

re := regexp.MustCompile(`\d+`)

// 单个
re.FindString("abc123def")           // "123"
re.FindStringIndex("abc123def")      // [3, 6] 字节位置

// 多个
re.FindAllString("a1b22c333", -1)    // ["1" "22" "333"]
re.FindAllString("a1b22c333", 2)     // ["1" "22"] 限制数量

2.3 Replace：替换

re := regexp.MustCompile(`\s+`)
re.ReplaceAllString("a   b\tc  d", " ")  // "a b c d"

// 函数式替换
re := regexp.MustCompile(`\d+`)
re.ReplaceAllStringFunc("a1b22c", func(s string) string {
    n, _ := strconv.Atoi(s)
    return strconv.Itoa(n * 10)  // 数字 ×10
})  // "a10b220c"

2.4 Split：分割

1 2	re := regexp.MustCompile(`[,;]\s*`) re.Split("a, b; c, d", -1) // ["a" "b" "c" "d"]

2.5 FindSubmatch：捕获组

re := regexp.MustCompile(`(\w+)@(\w+)\.(\w+)`)
match := re.FindStringSubmatch("alice@example.com")
// match[0] = "alice@example.com"  ← 完整匹配
// match[1] = "alice"               ← 第 1 组
// match[2] = "example"            ← 第 2 组
// match[3] = "com"                ← 第 3 组

// 命名捕获
re := regexp.MustCompile(`(?P<user>\w+)@(?P<domain>\w+)\.(?P<tld>\w+)`)
match := re.FindStringSubmatch("alice@example.com")
result := make(map[string]string)
for i, name := range re.SubexpNames() {
    if name != "" {
        result[name] = match[i]
    }
}
fmt.Println(result)
// map[domain:example tld:com user:alice]

3. 实战：日志分析

Nginx 访问日志格式：

1	192.168.1.1 - - [10/Oct/2023:13:55:36 -0700] "GET /api/users HTTP/1.1" 200 1234

type LogEntry struct {
    IP        string
    Time      string
    Method    string
    Path      string
    Status    int
    Size      int
}

var logRe = regexp.MustCompile(
    `^(?P<ip>\d+\.\d+\.\d+\.\d+) - - \[(?P<time>[^\]]+)\] ` +
    `"(?P<method>\w+) (?P<path>\S+) \S+" (?P<status>\d+) (?P<size>\d+)`,
)

func parseLog(line string) (*LogEntry, error) {
    m := logRe.FindStringSubmatch(line)
    if m == nil {
        return nil, errors.New("invalid log line")
    }
    status, _ := strconv.Atoi(m[5])
    size, _ := strconv.Atoi(m[6])
    return &LogEntry{
        IP:     m[1],
        Time:   m[2],
        Method: m[3],
        Path:   m[4],
        Status: status,
        Size:   size,
    }, nil
}

4. 实战：URL 参数解析

// 从 URL 提取参数值
re := regexp.MustCompile(`[?&](\w+)=([^&]+)`)
url := "https://example.com/search?q=golang&page=2&sort=desc"

params := make(map[string]string)
for _, m := range re.FindAllStringSubmatch(url, -1) {
    params[m[1]] = m[2]
}
fmt.Println(params)
// map[page:2 q:golang sort:desc]

更好的方法：用 net/url 包

import "net/url"

u, _ := url.Parse("https://example.com/search?q=golang&page=2")
q := u.Query()
fmt.Println(q.Get("q"))   // "golang"
fmt.Println(q.Get("page")) // "2"

5. 实战：邮箱/手机号/URL 验证

var (
    emailRe   = regexp.MustCompile(`^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$`)
    phoneRe   = regexp.MustCompile(`^1[3-9]\d{9}$`)
    urlRe     = regexp.MustCompile(`^https?://[^\s/$.?#].[^\s]*$`)
    ipv4Re    = regexp.MustCompile(`^(\d{1,3}\.){3}\d{1,3}$`)
    hexColor  = regexp.MustCompile(`^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$`)
)

func validateEmail(s string) bool {
    return emailRe.MatchString(s)
}

注意：正则验证不能 100% 准确。比如邮箱正则看似严格，但实际 a@b.c 也是合法邮箱。生产环境应该先正则粗筛 + 再发送验证邮件。

6. 性能优化

1. 预编译正则（最重要）：

// 错：每次调用都编译
func isPhone(s string) bool {
    return regexp.MustCompile(`^1[3-9]\d{9}$`).MatchString(s)
}

// 对：包级变量编译一次
var phoneRe = regexp.MustCompile(`^1[3-9]\d{9}$`)
func isPhone(s string) bool {
    return phoneRe.MatchString(s)
}

**2. 用 Compile 而不是 MustCompile**（如非配置/常量正则）。

3. 避免贪婪匹配：

// 贪婪：可能回溯
`<.+>`

// 非贪婪：更快
`<.+?>`

4. 用 regexp.MatchString 一次性检查：

1 2	ok, _ := regexp.MatchString(`^pattern`, s) // 一次性，内部编译 // 但只用于偶尔的检查，频繁还是预编译好

7. 高级特性

7.1 零宽断言

// 前瞻：(?=...)
re := regexp.MustCompile(`\w+(?=\.)`)  // 匹配 "." 前的单词
re.FindAllString("foo.bar.baz", -1)  // ["foo" "bar"]

// 后顾：(?<=...)
re := regexp.MustCompile(`(?<=\.)\w+`)  // 匹配 "." 后的单词
re.FindAllString("foo.bar.baz", -1)  // ["bar" "baz"]

7.2 非捕获组

1	re := regexp.MustCompile(`(?:foo\|bar)+`) // 圆括号不捕获

7.3 标志位

1
2
3

re := regexp.MustCompile(`(?i)abc`)  // 不区分大小写
re := regexp.MustCompile(`(?m)^abc`) // 多行模式（^ 匹配行首）
re := regexp.MustCompile(`(?s).*?`)  // 点号匹配换行符

8. 实战：从 HTML 提取数据

// 简单提取 <a href="...">title</a>
re := regexp.MustCompile(`<a[^>]+href="([^"]+)"[^>]*>([^<]+)</a>`)
html := `<a href="/about">About</a> <a href="/contact">Contact</a>`

for _, m := range re.FindAllStringSubmatch(html, -1) {
    fmt.Printf("link: %s -> %s\n", m[2], m[1])
}
// link: About -> /about
// link: Contact -> /contact

警告：生产环境用 golang.org/x/net/html 包，正则解析 HTML 容易出错。

9. 实战：批量提取/替换

// 把 markdown 链接 [text](url) 替换成 HTML <a href="url">text</a>
re := regexp.MustCompile(`\[([^\]]+)\]\(([^)]+)\)`)
md := "看 [官方文档](https://go.dev) 和 [Go 语言圣经](https://gopl.io)"

html := re.ReplaceAllStringFunc(md, func(s string) string {
    m := re.FindStringSubmatch(s)
    return fmt.Sprintf(`<a href="%s">%s</a>`, m[2], m[1])
})
fmt.Println(html)
// 看 <a href="https://go.dev">官方文档</a> 和 <a href="https://gopl.io">Go 语言圣经</a>

10. 字符串模板（text/template）

比正则更结构化的字符串处理：

import "text/template"

const greeting = `Hello, {{.Name}}!
You are {{.Age}} years old.
`

type Person struct {
    Name string
    Age  int
}

tmpl, _ := template.New("greet").Parse(greeting)
tmpl.Execute(os.Stdout, Person{Name: "Alice", Age: 25})
// Hello, Alice!
// You are 25 years old.

条件、循环、函数：

const tmpl = `
{{- range .Items}}
- {{.Name}}: ${{.Price}}
{{- end}}
Total: ${{.Total}}
`

template.Must(template.New("").Parse(tmpl)).Execute(os.Stdout, map[string]interface{}{
    "Items": []map[string]interface{}{
        {"Name": "Apple", "Price": 1.5},
        {"Name": "Bread", "Price": 3.0},
    },
    "Total": 4.5,
})

小结

场景	工具
简单匹配/提取	`regexp`
URL 参数	`net/url`
HTML 解析	`golang.org/x/net/html`
字符串模板	`text/template`
路径操作	`path/filepath`

正则最佳实践：

预编译正则为包级变量
避免回溯爆炸（RE2 引擎已经保证）
不要用正则解析 HTML/XML/JSON（用专用 parser）
测试用例要全（边界、Unicode、emoji）

下一节深入并发：sync.Mutex、sync.WaitGroup、context、连接池。

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/08/22/Go-11-正则与字符串高级处理/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！