Go 正则匹配之跨行匹配

2023-12-29 20:28
文章标签 go 匹配 正则 跨行

本文主要是介绍Go 正则匹配之跨行匹配，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

跨行匹配

一般正则匹配默认是按行来进行匹配的，如果要跨行匹配，需要使用 `(?s)` 来启用多行模式。

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."// fmt.Println(data)// re := regexp.MustCompile(`line.*And`)re := regexp.MustCompile(`(?s)line.*And`)match := re.FindString(data)fmt.Println(match)out := re.ReplaceAllString(data, "------")fmt.Println(out)
}
line. 
And
This is the first ------ this is the second line.

go 正则匹配相关的其他常用函数

Compile、MustCompile

同样的功能，不同的设计：

  1. Compile函数基于错误处理设计，将正则表达式编译成有效的可匹配格式，适用于用户输入场景。当用户输入的正则表达式不合法时，该函数会返回一个错误。
  2. MustCompile函数基于异常处理设计，适用于硬编码场景。当调用者明确知道输入不会引起函数错误时，要求调用者检查这个错误是不必要和累赘的。我们应该假设函数的输入一直合法，当调用者输入了不应该出现的输入时，就触发panic异常。

其实直接从 MustCompile 的实现可以看出，MustCompile 本质上是调用的 Compile ，如果表达式编译失败，直接 panic ，而 Compile 则会把 err 返回，由用户决定是否 panic 或进行其他处理：

// 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
}

FindString

FindString 用来返回匹配到的第一个字符串。

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.FindString(data)fmt.Println(match) // the first line
}

FindAllString

FindString 用来返回匹配到的所有的字符串。用户可以指定想要返回的匹配到的字符串的个数。

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.FindAllString(data, 3)fmt.Printf("%#v\n", match) // []string{"the first line", "the second line"}
}

Find

类似于FindString，只不过以字节数组的形式表示。

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.Find([]byte(data))// match := re.FindAll([]byte(data), 3)fmt.Printf("%#v\n", match)         // []byte{0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6c, 0x69, 0x6e, 0x65}fmt.Printf("%#v\n", string(match)) // "the first line"
}

FindAll

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)// match := re.Find([]byte(data))match := re.FindAll([]byte(data), 3)fmt.Printf("%#v\n", match) // [][]uint8{[]uint8{0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6c, 0x69, 0x6e, 0x65}, []uint8{0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, 0x6c, 0x69, 0x6e, 0x65}}
}

FindIndex

返回匹配字符串的起始位置和结束位置索引，未匹配到的话返回 nil

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.FindIndex([]byte(data))// match := re.FindAll([]byte(data), 3)fmt.Printf("%#v\n", match)                   // []int{8, 22}if match == nil {fmt.Println("match is nil")return}fmt.Printf("%#v\n", data[match[0]:match[1]]) // "the first line"
}

临时插入一个小知识，声明一个未初始化的 Array 或 Map ，其值初始为 nil。

package mainimport ("fmt"
)func main() {var a []intfmt.Printf("%#v\n", a) // []int(nil)fmt.Println(a == nil)  // truea = []int{}fmt.Printf("%#v\n", a) // []int{}fmt.Println(a == nil)  // falsevar m map[string]stringfmt.Printf("%#v\n", m) // map[string]string(nil)fmt.Println(m == nil)  // truem = map[string]string{}fmt.Printf("%#v\n", m) // map[string]string{}fmt.Println(m == nil)  // false
}

FindAllIndex

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.FindAllIndex([]byte(data), 3)// match := re.FindAll([]byte(data), 3)fmt.Printf("%#v\n", match) // [][]int{[]int{8, 22}, []int{37, 52}}if match == nil {fmt.Println("match is nil")return}for _, m := range match {fmt.Printf("%#v\n", data[m[0]:m[1]]) // "the first line"  "the second line"}
}

FindSubMatch

有些例子比较简单，就不多描述了

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.FindSubmatch([]byte(data))fmt.Printf("%#v\n", match) // [][]uint8{[]uint8{0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6c, 0x69, 0x6e, 0x65}}
}

FindAllSubMatch

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.FindAllSubmatch([]byte(data), 3)fmt.Printf("%#v\n", match) // [][][]uint8{[][]uint8{[]uint8{0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6c, 0x69, 0x6e, 0x65}}, //             [][]uint8{[]uint8{0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, 0x6c, 0x69, 0x6e, 0x65}}}
}

FindStringSubMatch

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.FindStringSubmatch(data)fmt.Printf("%#v\n", match) // []string{"the first line"}
}

FindAllStringSubMatch

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.FindAllStringSubmatch(data, 3)fmt.Printf("%#v\n", match) // [][]string{[]string{"the first line"}, []string{"the second line"}}
}

ReplaceAllString

将所有匹配到的字符串使用给定字符串进行替换。替换的字符可以引用匹配组的内容。

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the (.*) line`)out := re.ReplaceAllString(data, "$1") fmt.Printf("%#v\n", out) // "This is first. \nAnd this is second."
}

ReplaceAllFunc 

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)out := re.ReplaceAllFunc([]byte(data), func(bytes []byte) []byte {return []byte("[" + string(bytes) + "]")})fmt.Printf("%#v\n", out)         // []byte{0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x5b, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x5d, 0x2e, 0x20, 0xa, 0x41, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x5b, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x5d, 0x2e}fmt.Printf("%#v\n", string(out)) // "This is [the first line]. \nAnd this is [the second line]."
}

ReplaceAllStringFunc

可以编写函数来决定如何替换掉匹配到的字符串，其中匿名函数中参数 s 为匹配到的字符串。

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)out := re.ReplaceAllStringFunc(data, func(s string) string {return "[" + s + "]"})fmt.Printf("%#v\n", out) // "This is [the first line]. \nAnd this is [the second line]."
}

ReplaceAllLiteral

通过字面量替换，以字节数组的形式。

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the (.*) line`)out := re.ReplaceAllLiteral([]byte(data), []byte("$1"))fmt.Printf("%#v\n", out)         // []byte{0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x24, 0x31, 0x2e, 0x20, 0xa, 0x41, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x24, 0x31, 0x2e}fmt.Printf("%#v\n", string(out)) // "This is $1. \nAnd this is $1."
}

ReplaceAllLiteralString

替换的字符串被当作字符串字面量进行处理。

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the (.*) line`)out := re.ReplaceAllLiteralString(data, "$1")fmt.Printf("%#v\n", out) // "This is $1. \nAnd this is $1."
}

ReplaceAll

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)out := re.ReplaceAll([]byte(data), []byte("---replace string---"))fmt.Printf("%#v\n", out)         // []byte{0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x2d, 0x2d, 0x2d, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2d, 0x2d, 0x2d, 0x2e, 0x20, 0xa, 0x41, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x2d, 0x2d, 0x2d, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2d, 0x2d, 0x2d, 0x2e}fmt.Printf("%#v\n", string(out)) // "This is ---replace string---. \nAnd this is ---replace string---."
}

MatchString

正则模式是否有匹配到字符串。

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.MatchString(data)fmt.Printf("%#v\n", match) // truere = regexp.MustCompile(`the x.* line`)match = re.MatchString(data)fmt.Printf("%#v\n", match) // false
}

Match

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)match := re.Match([]byte(data))fmt.Printf("%#v\n", match) // truere = regexp.MustCompile(`the x.* line`)match = re.Match([]byte(data))fmt.Printf("%#v\n", match) // false
}

Split

将正则匹配到的字符串作为分隔符，对原字符串进行 Split 分隔，返回分隔后生成的数据。用户可以指定分隔后数组的长度（不超过全部分隔后的数组长度）。

package mainimport ("fmt""regexp"
)func main() {data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the .* line`)out := re.Split(data, 1)fmt.Printf("%#v\n", out) // []string{"This is the first line. \nAnd this is the second line."}out = re.Split(data, 2)fmt.Printf("%#v\n", out) // []string{"This is ", ". \nAnd this is the second line."}out = re.Split(data, 3)fmt.Printf("%#v\n", out) // []string{"This is ", ". \nAnd this is ", "."}out = re.Split(data, 4)fmt.Printf("%#v\n", out) // []string{"This is ", ". \nAnd this is ", "."}
}

NumSubexp

返回正则模式子组的数目

package mainimport ("fmt""regexp"
)func main() {// data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the (.*) lin()e`)// out := re.FindString(data)// fmt.Printf("%#v\n", out)fmt.Printf("%#v\n", re.NumSubexp()) // 2
}

LiteralPrefix

返回所有匹配项都共同拥有的前缀（去除可变元素）

prefix：共同拥有的前缀

complete：如果 prefix 就是正则表达式本身，则返回 true，否则返回 false

package mainimport ("fmt""regexp"
)func main() {// data := "This is the first line. \nAnd this is the second line."re := regexp.MustCompile(`the (.*) line`)prefix, complete := re.LiteralPrefix()fmt.Printf("%#v\n", prefix)   // "the "fmt.Printf("%#v\n", complete) // falsere = regexp.MustCompile(`the line`)prefix, complete = re.LiteralPrefix()fmt.Printf("%#v\n", prefix)   // "the line"fmt.Printf("%#v\n", complete) // true
}

这篇关于Go 正则匹配之跨行匹配的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/550613。

相关文章

深入理解Go语言中二维切片的使用

深入理解Go语言中二维切片的使用

《深入理解Go语言中二维切片的使用》本文深入讲解了Go语言中二维切片的概念与应用,用于表示矩阵、表格等二维数据结构,文中通过示例代码介绍的非常详细,需要的朋友们下面随着小编来一起学习学习吧... 目录引言二维切片的基本概念定义创建二维切片二维切片的操作访问元素修改元素遍历二维切片二维切片的动态调整追加行动态
阅读更多...
go中的时间处理过程

go中的时间处理过程

《go中的时间处理过程》：本文主要介绍go中的时间处理过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录1 获取当前时间2 获取当前时间戳3 获取当前时间的字符串格式4 相互转化4.1 时间戳转时间字符串 (int64 > string)4.2 时间字符串转时间
阅读更多...
Go语言中make和new的区别及说明

Go语言中make和new的区别及说明

《Go语言中make和new的区别及说明》：本文主要介绍Go语言中make和new的区别及说明,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录1 概述2 new 函数2.1 功能2.2 语法2.3 初始化案例3 make 函数3.1 功能3.2 语法3.3 初始化
阅读更多...
Go语言中nil判断的注意事项(最新推荐)

Go语言中nil判断的注意事项(最新推荐)

《Go语言中nil判断的注意事项(最新推荐)》本文给大家介绍Go语言中nil判断的注意事项,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录1.接口变量的特殊行为2.nil的合法类型3.nil值的实用行为4.自定义类型与nil5.反射判断nil6.函数返回的
阅读更多...
Go语言数据库编程GORM 的基本使用详解

Go语言数据库编程GORM 的基本使用详解

《Go语言数据库编程GORM的基本使用详解》GORM是Go语言流行的ORM框架,封装database/sql,支持自动迁移、关联、事务等,提供CRUD、条件查询、钩子函数、日志等功能,简化数据库操作... 目录一、安装与初始化1. 安装 GORM 及数据库驱动2. 建立数据库连接二、定义模型结构体三、自动迁
阅读更多...
Go语言代码格式化的技巧分享

Go语言代码格式化的技巧分享

《Go语言代码格式化的技巧分享》在Go语言的开发过程中,代码格式化是一个看似细微却至关重要的环节,良好的代码格式化不仅能提升代码的可读性,还能促进团队协作,减少因代码风格差异引发的问题,Go在代码格式... 目录一、Go 语言代码格式化的重要性二、Go 语言代码格式化工具：gofmt 与 go fmt（一）
阅读更多...
Go学习记录之runtime包深入解析

Go学习记录之runtime包深入解析

《Go学习记录之runtime包深入解析》Go语言runtime包管理运行时环境,涵盖goroutine调度、内存分配、垃圾回收、类型信息等核心功能,：本文主要介绍Go学习记录之runtime包的... 目录前言：一、runtime包内容学习1、作用：① Goroutine和并发控制：② 垃圾回收：③ 栈和
阅读更多...
Go语言中泄漏缓冲区的问题解决

Go语言中泄漏缓冲区的问题解决

《Go语言中泄漏缓冲区的问题解决》缓冲区是一种常见的数据结构,常被用于在不同的并发单元之间传递数据,然而,若缓冲区使用不当,就可能引发泄漏缓冲区问题,本文就来介绍一下问题的解决,感兴趣的可以了解一下... 目录引言泄漏缓冲区的基本概念代码示例：泄漏缓冲区的产生项目场景：Web 服务器中的请求缓冲场景描述代码
阅读更多...
Go语言如何判断两张图片的相似度

Go语言如何判断两张图片的相似度

《Go语言如何判断两张图片的相似度》这篇文章主要为大家详细介绍了Go语言如何中实现判断两张图片的相似度的两种方法,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 在介绍技术细节前，我们先来看看图片对比在哪些场景下可以用得到：图片去重：自动删除重复图片，为存储空间"瘦身"。想象你是一个
阅读更多...
Go语言中Recover机制的使用

Go语言中Recover机制的使用

《Go语言中Recover机制的使用》Go语言的recover机制通过defer函数捕获panic,实现异常恢复与程序稳定性,具有一定的参考价值,感兴趣的可以了解一下... 目录引言Recover 的基本概念基本代码示例简单的 Recover 示例嵌套函数中的 Recover项目场景中的应用Web 服务器中
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2