脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 脚本专栏 → Golang → Go regexp正则表达式操作

Go中regexp包常见的正则表达式操作

 更新时间：2025年02月21日 10:10:12   作者：学亮编程手记  
本文主要介绍了Go中regexp包常见的正则表达式操作,包括匹配、查找、替换和分割字符串等,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

在 Golang 中，regexp 包用于处理正则表达式操作。以下是一些常见的正则表达式操作的代码示例：

1. 简单匹配（MatchString）

用于检查字符串是否匹配某个正则表达式。

package main

import (
	"fmt"
	"regexp"
)

func main() {
	pattern := `^hello`
	text := "hello world"

	match, _ := regexp.MatchString(pattern, text)
	fmt.Println("Matched:", match) // 输出: Matched: true
}

2. 编译正则表达式（Compile 和 MustCompile）

通过 regexp.Compile 或 regexp.MustCompile 编译正则表达式以提高性能。

package main

import (
	"fmt"
	"regexp"
)

func main() {
	// Compile 返回 error，如果正则无效
	re, err := regexp.Compile(`\d+`)
	if err != nil {
		fmt.Println("Error compiling regex:", err)
		return
	}

	text := "Order number 12345"
	fmt.Println("Matched:", re.MatchString(text)) // 输出: Matched: true

	// MustCompile 会 panic，如果正则无效
	re2 := regexp.MustCompile(`\d+`)
	fmt.Println("Matched:", re2.MatchString(text)) // 输出: Matched: true
}

3. 查找字符串中的第一个匹配项（FindString 和 FindStringSubmatch）

  • FindString 返回第一个匹配的字符串。
  • FindStringSubmatch 返回第一个匹配的字符串以及捕获的子组。
package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`(\d+)-(\d+)-(\d+)`)
	text := "Today's date is 2025-01-25."

	// 找到第一个匹配的字符串
	match := re.FindString(text)
	fmt.Println("Found:", match) // 输出: Found: 2025-01-25

	// 找到第一个匹配及其子组
	submatches := re.FindStringSubmatch(text)
	fmt.Println("Submatches:", submatches) // 输出: Submatches: [2025-01-25 2025 01 25]
}

4. 查找所有匹配项（FindAllString 和 FindAllStringSubmatch）

  • FindAllString 返回所有匹配的字符串。
  • FindAllStringSubmatch 返回所有匹配的字符串及其子组。
package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`\d+`)
	text := "Numbers: 123, 456, and 789."

	// 找到所有匹配的字符串
	matches := re.FindAllString(text, -1)
	fmt.Println("Matches:", matches) // 输出: Matches: [123 456 789]

	// 限制返回的匹配数量
	limitedMatches := re.FindAllString(text, 2)
	fmt.Println("Limited Matches:", limitedMatches) // 输出: Limited Matches: [123 456]
}

5. 替换字符串（ReplaceAllString）

用于替换所有匹配的字符串。

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`\d+`)
	text := "Order 123, 456, and 789."

	// 替换所有匹配的数字为 XXX
	result := re.ReplaceAllString(text, "XXX")
	fmt.Println("Replaced:", result) // 输出: Replaced: Order XXX, XXX, and XXX.
}

6. 替换字符串（ReplaceAllStringFunc）

通过一个函数动态替换匹配的字符串。

package main

import (
	"fmt"
	"regexp"
	"strings"
)

func main() {
	re := regexp.MustCompile(`[a-z]+`)
	text := "hello world GO!"

	// 将匹配的字符串替换为大写
	result := re.ReplaceAllStringFunc(text, strings.ToUpper)
	fmt.Println("Replaced:", result) // 输出: Replaced: HELLO WORLD GO!
}

7. 分割字符串（Split）

使用正则表达式分割字符串。

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`\s+`) // 匹配空白字符
	text := "Split   this     string!"

	// 分割字符串
	parts := re.Split(text, -1)
	fmt.Println("Parts:", parts) // 输出: Parts: [Split this string!]
}

8. 提取子组并命名（Named Captures）

通过命名捕获组提取特定的子组。

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`(?P<Year>\d{4})-(?P<Month>\d{2})-(?P<Day>\d{2})`)
	text := "Date: 2025-01-25."

	// 提取所有子组
	submatches := re.FindStringSubmatch(text)
	fmt.Println("Submatches:", submatches) // 输出: Submatches: [2025-01-25 2025 01 25]

	// 提取命名的子组
	names := re.SubexpNames()
	for i, name := range names {
		if name != "" {
			fmt.Printf("%s: %s\n", name, submatches[i])
		}
	}
	// 输出:
	// Year: 2025
	// Month: 01
	// Day: 25
}

9. 检查字符串起始位置匹配（MatchString 和 Match）

  • MatchString 检查整个字符串。
  • Match 检查字节切片。
package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`^hello`)

	text := "hello world"
	bytes := []byte("hello bytes")

	fmt.Println("String Match:", re.MatchString(text)) // 输出: String Match: true
	fmt.Println("Bytes Match:", re.Match(bytes))      // 输出: Bytes Match: true
}

10. 替换字节切片（ReplaceAll）

与字符串操作类似，但作用于字节切片。

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`\d+`)
	text := []byte("Order 123, 456, and 789.")

	// 替换所有匹配的数字为 XXX
	result := re.ReplaceAll(text, []byte("XXX"))
	fmt.Println("Replaced:", string(result)) // 输出: Replaced: Order XXX, XXX, and XXX.
}

到此这篇关于Go中regexp包常见的正则表达式操作的文章就介绍到这了,更多相关Go regexp正则表达式操作内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！ 

您可能感兴趣的文章:

相关文章

  • Go语言正则表达式的使用详解

    Go语言正则表达式的使用详解

    正则表达式是一种进行模式匹配和文本操纵的功能强大的工具。这篇文章主要介绍了Go正则表达式使用,本文给大家介绍的非常详细，对大家的工作或学习具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-03-03
  • Go语言公司gitlab私有仓库依赖拉取配置的两种实现方式

    Go语言公司gitlab私有仓库依赖拉取配置的两种实现方式

    文章主要介绍了如何在Go语言中管理私有仓库依赖,Go语言目前使用官方的gomodules来管理依赖,对于公有仓库使用goget直接操作即可,但私有仓库则需要额外的配置,下面就来详细的介绍一下如何配置,感兴趣的可以了解一下
    2025-11-11
  • Fedora14 Linux系统安装Golang开发环境笔记

    Fedora14 Linux系统安装Golang开发环境笔记

    这篇文章主要介绍了Fedora14 Linux系统安装Golang开发环境笔记,本文讲解了2种安装方法,需要的朋友可以参考下
    2014-10-10
  • golang recover函数使用中的一些坑解析

    golang recover函数使用中的一些坑解析

    这篇文章主要为大家介绍了golang recover函数使用中的一些坑解析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-02-02
  • Golang 类型转换的实现(断言、强制、显式类型)

    Golang 类型转换的实现(断言、强制、显式类型)

    将一个值从一种类型转换到另一种类型,便发生了类型转换,在go可以分为断言、强制、显式类型转换,本文就详细的介绍一下这就几种转换方式,具有一定的参考价值,感兴趣的可以了解一下
    2023-09-09
  • Go语言Gin处理响应方式详解

    Go语言Gin处理响应方式详解

    gin框架封装了常用的数据格式方法响应于客户端,下面这篇文章主要给大家介绍了关于Go语言Gin处理响应方式的相关资料,文中通过图文介绍的非常详细,需要的朋友可以参考下
    2023-01-01
  • golang 通用Contains方法分享

    golang 通用Contains方法分享

    这篇文章主要介绍了golang 通用Contains方法分享，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2021-04-04
  • Go语言学习之数组的用法详解

    Go语言学习之数组的用法详解

    数组是相同数据类型的一组数据的集合，数组一旦定义长度不能修改，数组可以通过下标（或者叫索引)来访问元素。本文将通过示例详细讲解Go语言中数组的使用，需要的可以参考一下
    2022-04-04
  • Go 代码规范错误处理示例经验总结

    Go 代码规范错误处理示例经验总结

    这篇文章主要为大家介绍了Go 代码规范错误处理示例实战经验总结，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-08-08
  • goweb模板语法html/template

    goweb模板语法html/template

    ​在Go语言里, html/template 包主要用于安全地生成HTML输出,它能够有效防止跨站脚本攻击（XSS）,借助模板语法将数据动态填充到HTML文件中,下面就来详细的介绍一下
    2026-02-02

最新评论