Go语言正则表达式完全指南

最新推荐文章于 2025-06-07 13:22:36 发布
最新推荐文章于 2025-06-07 13:22:36 发布
阅读量505 收藏 7
点赞数 7
CC 4.0 BY-SA版权
文章标签： golang 正则表达式 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hzether/article/details/145084107

Go语言正则表达式完全指南

Go语言通过 regexp 包提供了强大的正则表达式支持。本指南将详细介绍Go中正则表达式的使用方法和最佳实践。

1. 基础知识

1.1 导入正则表达式包

import "regexp"

1.2 创建正则表达式

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // 方式1：直接编译
    pattern := regexp.MustCompile(`\d+`)

    // 方式2：处理错误的编译方式
    pattern, err := regexp.Compile(`\d+`)
    if err != nil {
        panic(err)
    }
}

1.3 基本匹配方法

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "Hello, my phone is 123-456-7890"
    pattern := regexp.MustCompile(`\d+`)

    // 1. FindString - 查找第一个匹配
    first := pattern.FindString(text)
    fmt.Println(first) // 输出: "123"

    // 2. FindAllString - 查找所有匹配
    all := pattern.FindAllString(text, -1)
    fmt.Println(all) // 输出: ["123", "456", "7890"]

    // 3. MatchString - 检查是否匹配
    isMatch := pattern.MatchString(text)
    fmt.Println(isMatch) // 输出: true

    // 4. FindStringIndex - 查找位置
    index := pattern.FindStringIndex(text)
    fmt.Println(index) // 输出起始和结束位置
}

2. 正则表达式语法

2.1 字符匹配

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "Python3 is awesome! Price: $99.99"

    // 匹配单个字符
    digit := regexp.MustCompile(`\d`)
    fmt.Println(digit.FindAllString(text, -1))    // 匹配数字

    word := regexp.MustCompile(`\w`)
    fmt.Println(word.FindAllString(text, -1))     // 匹配字母/数字/下划线

    space := regexp.MustCompile(`\s`)
    fmt.Println(space.FindAllString(text, -1))    // 匹配空白字符

    // 自定义字符类
    vowels := regexp.MustCompile(`[aeiou]`)
    fmt.Println(vowels.FindAllString(text, -1))   // 匹配元音字母
}

2.2 数量词

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "go golang gooo gooooo"

    // 不同数量词的使用
    pattern1 := regexp.MustCompile(`go*`)         // 匹配 g 后面跟着 0 个或多个 o
    pattern2 := regexp.MustCompile(`go+`)         // 匹配 g 后面跟着 1 个或多个 o
    pattern3 := regexp.MustCompile(`go?`)         // 匹配 g 后面跟着 0 个或 1 个 o
    pattern4 := regexp.MustCompile(`go{2}`)       // 匹配 g 后面跟着正好 2 个 o
    pattern5 := regexp.MustCompile(`go{2,4}`)     // 匹配 g 后面跟着 2 到 4 个 o

    fmt.Println(pattern1.FindAllString(text, -1))
    fmt.Println(pattern2.FindAllString(text, -1))
    fmt.Println(pattern3.FindAllString(text, -1))
    fmt.Println(pattern4.FindAllString(text, -1))
    fmt.Println(pattern5.FindAllString(text, -1))
}

3. 高级特性

3.1 分组和捕获

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "John Smith, Jane Doe, Bob Johnson"

    // 基本分组
    namePattern := regexp.MustCompile(`(\w+)\s(\w+)`)
    
    // FindStringSubmatch 返回完整匹配和所有子匹配
    matches := namePattern.FindAllStringSubmatch(text, -1)
    for _, match := range matches {
        fmt.Printf("Full: %s, First: %s, Last: %s\n", match[0], match[1], match[2])
    }

    // 命名分组
    namedPattern := regexp.MustCompile(`(?P<first>\w+)\s(?P<last>\w+)`)
    for _, match := range namedPattern.FindAllStringSubmatch(text, -1) {
        fmt.Printf("Full: %s, First: %s, Last: %s\n", match[0], match[1], match[2])
    }
}

3.2 替换操作

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "My phone numbers are 123-456-7890 and 098-765-4321"

    // 简单替换
    pattern := regexp.MustCompile(`\d{3}-\d{3}-\d{4}`)
    replaced := pattern.ReplaceAllString(text, "XXX-XXX-XXXX")
    fmt.Println(replaced)

    // 使用函数进行替换
    replacedFunc := pattern.ReplaceAllStringFunc(text, func(s string) string {
        return "CENSORED"
    })
    fmt.Println(replacedFunc)
}

4. 实用示例

4.1 数据验证

package main

import (
    "regexp"
)

// 验证电子邮件地址
func ValidateEmail(email string) bool {
    pattern := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
    return pattern.MatchString(email)
}

// 验证中国手机号
func ValidatePhone(phone string) bool {
    pattern := regexp.MustCompile(`^1[3-9]\d{9}$`)
    return pattern.MatchString(phone)
}

// 验证密码强度
func ValidatePassword(password string) bool {
    // 至少8位，包含大小写字母和数字
    pattern := regexp.MustCompile(`^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$`)
    return pattern.MatchString(password)
}

4.2 文本处理

package main

import (
    "regexp"
    "strings"
)

// 提取URL
func ExtractURLs(text string) []string {
    pattern := regexp.MustCompile(`https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+`)
    return pattern.FindAllString(text, -1)
}

// 清理文本（删除多余空白字符）
func CleanText(text string) string {
    pattern := regexp.MustCompile(`\s+`)
    return strings.TrimSpace(pattern.ReplaceAllString(text, " "))
}

// 提取日期
func ExtractDates(text string) []string {
    pattern := regexp.MustCompile(`\d{4}[-/]\d{1,2}[-/]\d{1,2}|\d{1,2}[-/]\d{1,2}[-/]\d{4}`)
    return pattern.FindAllString(text, -1)
}

5. 性能优化

5.1 预编译正则表达式

package main

import (
    "regexp"
    "sync"
)

// 使用包级变量存储编译后的正则表达式
var (
    emailRegex    = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
    phoneRegex    = regexp.MustCompile(`^1[3-9]\d{9}$`)
    passwordRegex = regexp.MustCompile(`^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$`)
)

// 在并发环境中安全使用正则表达式
type SafeRegexp struct {
    sync.RWMutex
    regex *regexp.Regexp
}

func (sr *SafeRegexp) MatchString(s string) bool {
    sr.RLock()
    defer sr.RUnlock()
    return sr.regex.MatchString(s)
}

5.2 优化建议

  1. 避免过度使用回溯
// 不好的写法 - 可能导致灾难性回溯
pattern := regexp.MustCompile(`.*foo.*`)

// 好的写法
pattern := regexp.MustCompile(`[^/]*foo[^/]*`)
  1. 使用适当的锚点
// 不好的写法
pattern := regexp.MustCompile(`\d+`)

// 好的写法 - 使用锚点限制匹配范围
pattern := regexp.MustCompile(`^\d+$`)

6. 常见问题和解决方案

6.1 处理多行文本

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := `First Line
    Second Line
    Third Line`

    // 使用(?m)标志启用多行模式
    pattern := regexp.MustCompile(`(?m)^.*Line`)
    matches := pattern.FindAllString(text, -1)
    fmt.Println(matches)
}

6.2 Unicode支持

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "Hello 你好 こんにちは"

    // 匹配Unicode字符
    pattern := regexp.MustCompile(`\p{Han}+`)  // 匹配汉字
    matches := pattern.FindAllString(text, -1)
    fmt.Println(matches)  // 输出: [你好]
}

7. 测试正则表达式

package main

import (
    "regexp"
    "testing"
)

func TestEmailValidation(t *testing.T) {
    tests := []struct {
        email string
        want  bool
    }{
        {"test@example.com", true},
        {"invalid.email", false},
        {"user@domain.co.uk", true},
    }

    for _, tt := range tests {
        got := ValidateEmail(tt.email)
        if got != tt.want {
            t.Errorf("ValidateEmail(%q) = %v; want %v", tt.email, got, tt.want)
        }
    }
}

总结

Go语言的正则表达式实现具有以下特点：

  1. 性能优秀，支持预编译
  2. 语法简洁，API设计清晰
  3. 完整支持Unicode
  4. 线程安全

最佳实践：

  1. 总是使用反引号（`）来定义正则表达式字符串，避免过度转义
  2. 预编译频繁使用的正则表达式
  3. 在性能关键场景使用适当的锚点和限制
  4. 编写单元测试验证正则表达式的正确性
  5. 注意并发安全性

记住：在Go中使用正则表达式时，简单性和可维护性同样重要。避免编写过于复杂的表达式，适当拆分复杂的匹配逻辑可以提高代码的可维护性。

golang-正则表达式
wtt234的专栏
06-19 3104
GO的正则的事项； 一、 Regexp包提供了16个方法，用于匹配正则表达式搜索结果。方法名满足如下正则表达式： Find(All)?(String)?(Submatch)?(Index)?Regexp包提供了16个方法，用于匹配正则表达式搜索结果。方法名满足如下正则表达式： Find(All)?(String)?(Submatch)?(Index)? RE2语法: https://github.com/google/re2 Find(All)?(String)?(Submatch)?(Ind
基础知识 - Golang 中的正则表达式
weixin_30642561的博客
08-19 590
------------------------------------------------------------ Golang中的正则表达式 ------------------------------------------------------------ 用法： ------------------------------ 单一： ...
Golang——10、日志处理和正则处理
最新发布
Talon的博客
06-07 842
本文介绍了go-zero框架中的日志处理包logx和Golang正则处理包regexp的使用方法。 logx日志处理部分： 概述logx的特点：统一日志格式、自动切割、多输出模式、链路追踪等 详细说明LogConf配置项及各参数含义 提供常用日志方法示例(Info/Error/Debug等) 演示日志初始化和panic捕获 正则处理部分： 介绍正则表达式基本语法 展示MatchString基本匹配用法 说明MustCompile和FindAllString等常见函数 提供字符串匹配数字等实用示例 全文通过代
golang正则表达式
boshuzhang的专栏
09-17 240
/* go正则表达式 go内置了对正则表达式的支持 这里正则表达式常规用法例子 */ package main import ( "bytes" "fmt" "regexp" ) func main() { /* 测试模式是否匹配字符串 */ match, _ := regexp.MatchString("p([a-...
golang 正则表达式
秋̶᭄ꦿ攻城狮࿆ྂ
10-09 5930
Go于2009年11月正式宣布推出，成为开放源代码项目，并在Linux及Mac OS X平台上进行了实现，后来追加了Windows系统下的实现。24 备注：这就是最终结果了,别忘了”+“可以用”*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?(包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))(可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)(网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)
Golang 正则表达式
月糖花缘ヾ(=ﾟ･ﾟ=)ﾉ喵♪
11-01 1418
如果没有匹配的字符串，那么它回返回一个空的字符串，当然如果你的正则表达式就是要匹配空字符串的话，它也会返回空字符串。假如正则表达式非法，那么 Compile() 方法回返回 error ,而 MustCompile() 编译非法正则表达式时不会返回 error ，而是返回 panic。ReplaceAllStringFunc 返回一个字符串的副本，其中正则表达式的所有匹配项都已替换为指定函数的返回值。FindStringSubmatch 返回包含匹配项的字符串切片，包括来自捕获组的字符串。
Go语言正则表达式完全指南：匹配、查找与替换
"Go语言正则表达式的使用详解，涵盖了正则表达式的匹配准则、功能以及如何使用Go标准库中的`regexp`包进行操作。主要介绍了`Match`、`MatchReader`、`MatchString`、`Compile`和`MustCompile`等函数，以及通过`...
MATLAB语言的正则表达式
2401_90032167的博客
01-05 1288
正则表达式（Regular Expression，简称 regex）是一种用于描述字符串模式的工具。它可以用来检测字符串中是否存在某种模式、提取特定内容、替换字符串中的子串等。正则表达式的核心在于其语法规则，借助这些规则，我们可以构造用于匹配复杂字符串的表达式。正则表达式是 MATLAB 中一个非常强大的工具，可以在字符串处理、数据清洗和信息提取等多个场景下发挥重要作用。通过本文的介绍，读者应该能够掌握 MATLAB 中正则表达式的基本使用方法和常见功能。
Golang正则表达式编程指南
Go语言自从发布以来，以其简洁、高效的特点吸引了大量开发者的...考虑到文件名“re-master”，可能是在强调对Go语言正则表达式进行更深层次的探索与掌握，以便在实际的开发工作中能够更加熟练和优雅地使用这些功能。
Linux正则表达式完全指南：基础与应用
正则表达式在Linux中是强大的文本处理工具，广泛应用于命令行工具和各种编程语言中。它们由普通字符和特殊字符（元字符）组成，允许用户创建复杂的模式来匹配和处理文本。 1. **元字符与转义字符** 元字符是具有...
Go语言正则表达式处理新项目：结构化字段与合理表达式
结合文件标题和描述，“go-restructure”项目看起来是为了改善正则表达式在Go语言中的使用体验，特别是利用Go语言的结构体特性来提高代码的可读性和易用性。一般而言，该项目可能提供了一种机制，使得用户可以将正则...
浅析golang 正则表达式
10-14
Go（又称Golang）是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。这篇文章给大家介绍golang 正则表达式的相关知识，感兴趣的朋友跟随小编一起看看吧
Golang中的正则表达式
grb123的博客
10-06 1069
Golang的regexp包正则表达式，各种正则示例
Golang —— 正则表达式
qq_45914985的博客
12-11 2362
正则表达式是一种进行模式匹配和文本操纵的复杂而又强大的工具。虽然正则表达式比纯粹的文本匹配效率低，但是它却更灵活。按照它的语法规则，随需构造出的匹配模式就能够从原始文本中筛选出几乎任何你想要得到的字符组合。 Go语言通过regexp标准包为正则表达式提供了官方支持，如果你已经使用过其他编程语言提供的正则相关功能，那么你应该对Go语言版本的不会太陌生，但是它们之间也有一些小的差异，因为Go实现的是RE2标准，除了\C。 其实字符串处理我们可以使用strings包来进行搜索(Contains、Index)、替换
Golang正则表达式
geek99_guo的博客
03-19 140
正则表达式，（英语：Regular Expression，在代码中常简写为regex、regexp或RE），正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。例如：用户注册，邮箱验证、手机号码验证、爬虫字符串匹配等。
Golang 正则表达式_goland 密码的 正则表达式
2401_84247849的博客
04-12 1041
1.1 正则表达式 - 教程 1.2 golang 正则 regexp包使用func GetRegexResult(str, rule string) ([]string, error) { reg, err := regexp.Compile(rule) if reg == nil || err != nil { return nil, errors.New(“正则Compile错误:” + err.Error()) } //提取关键信息 result := reg.FindAllString(str,
Go语言的正则表达式
2501_90200002的博客
01-15 572
正则表达式（Regular Expression，简称regex）是一种用于描述字符串集合的工具，它使用特定的语法来定义字符串模式。正则表达式在文本处理中非常常见，广泛应用于验证输入、替换文本、提取信息等任务。无论是对日志文件的解析，还是对用户输入的验证，正则表达式都可以提供简洁而有效的解决方案。Go语言的正则表达式功能强大，从基础的匹配、查找和替换，到高级的分组、断言以及在实际应用中的重要角色，正则表达式在处理字符串时提供极大的便利。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

老大白菜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值