GO:Regexp正则操作

最新推荐文章于 2024-05-16 09:58:35 发布

lsron

最新推荐文章于 2024-05-16 09:58:35 发布

阅读量1.2k

点赞数

分类专栏： Go语言文章标签： golang go go语言

本文链接：https://blog.csdn.net/weixin_38695343/article/details/115186349

版权

Go语言专栏收录该内容

7 篇文章 0 订阅

订阅专栏

概述

正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。

正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。

在go语言中，regexp 包实现正则表达式搜索。regexp接受通用的正则表达式语法，与Perl,Python和其他语言的语法相同，如果想查看golang正则表达式语法的详细概述,可以运行go命令：

go doc regrexp/syntax

附上正则表达式-语法教程

常用方法

参数说明：

pattern:要查找的正则表达式
matched:返回是否找到匹配项，布尔类型
re *Regexp:go正则匹配实例对象

1. func Match(pattern string, b []byte)(matchd bool, err error)

匹配检查文本正则表达式是否与字节片匹配

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	matched, err := regexp.Match(`foo.*`, []byte(`seafood`))
	fmt.Println(matched, err)
	matched, err = regexp.Match(`bar.*`, []byte(`seafood`))
	fmt.Println(matched, err)
	matched, err = regexp.Match(`a(b`, []byte(`seafood`))
	fmt.Println(matched, err)

}

2. func MatchString(pattern string, s string) (matched bool, err error)

检查文本正则表达式是否匹配字符串

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	matched, err := regexp.MatchString("foo.*", "seafood")
	fmt.Println(matched, err)
	matched, err = regexp.MatchString("bar.*", "seafood")
	fmt.Println(matched, err)
	matched, err = regexp.MatchString("a(b", "seafood")
	fmt.Println(matched, err)
}

3. func MustCompile(str string) *Regexp

MustCompile 就像编译，但如果表达式不能被解析就会发生混乱。它简化了保存已编译正则表达式的全局变量的安全初始化。

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	// Compile the expression once, usually at init time.
	// Use raw strings to avoid having to quote the backslashes.
	var validID = regexp.MustCompile(`^[a-z]+\[[0-9]+\]$`)

	fmt.Println(validID.MatchString("adam[23]"))
	fmt.Println(validID.MatchString("eve[7]"))
	fmt.Println(validID.MatchString("Job[48]"))
	fmt.Println(validID.MatchString("snakey"))
}

4. func (re *Regexp) Find(b []byte) []byte

查找返回一个片段，其中包含正则表达式b中最左边匹配的文本。返回值 nil 表示不匹配。

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`foo.?`)
	fmt.Printf("%q\n", re.Find([]byte(`seafood fool`)))

}

5. func (re *Regexp) FindIndex(b []byte) (loc []int)

FindIndex 返回一个两个元素的整数切片，用于定义正则表达式 b 中最左边匹配的位置。匹配本身在 b [loc0：loc1]。返回值 nil 表示不匹配。

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	content := []byte(`
	# comment line
	option1: value1
	option2: value2
`)
	// Regex pattern captures "key: value" pair from the content.
	pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)

	loc := pattern.FindIndex(content)
	fmt.Println(loc)
	fmt.Println(string(content[loc[0]:loc[1]]))
}

6. func (re *Regexp) FindAll(b []byte, n int) [][]byte

FindAll 是 Find 的所有版本；它返回表达式的所有连续匹配的一部分，如包注释中的 ‘All’ 描述所定义。返回值 nil 表示不匹配。

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`foo.?`)
	fmt.Printf("%q\n", re.FindAll([]byte(`seafood fool`), -1))

}

7. func (re *Regexp) FindString(s string, n int) []string

FindString 返回一个字符串，其中包含正则表达式的s中最左边匹配的文本。如果不匹配，则返回值为空字符串，但如果正则表达式成功匹配空字符串，则它也将为空。如果有必要区分这些情况，请使用 FindStringIndex 或 FindStringSubmatch 。

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`foo.?`)
	fmt.Printf("%q\n", re.FindString("seafood fool"))
	fmt.Printf("%q\n", re.FindString("meat"))
}

8. func (re *Regexp) FindStringIndex(s string) (loc []int)

FindStringIndex 返回一个整数的两个元素切片，用于定义正则表达式的 s 中最左边匹配的位置。匹配本身在 s [loc0：loc1] 。返回值 nil 表示不匹配。

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile("ab?")
	fmt.Println(re.FindStringIndex("tablett"))
	fmt.Println(re.FindStringIndex("foo") == nil)
}

9. func (re *Regexp) FindAllString(s string, n int) []string

FindAllString 是 FindString 的 'All’版本；它返回表达式的所有连续匹配的一部分，如包注释中的 ‘All’ 描述所定义。返回值 nil 表示不匹配。

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile("a.")
	fmt.Println(re.FindAllString("paranormal", -1))
	fmt.Println(re.FindAllString("paranormal", 2))
	fmt.Println(re.FindAllString("graal", -1))
	fmt.Println(re.FindAllString("none", -1))
}

10. func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string

FindAllStringSubmatch 是 FindStringSubmatch 的 ‘All’ 版本; 它返回表达式的所有连续匹配的一部分，如包注释中的 ‘All’ 描述所定义。返回值 nil 表示不匹配。

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile("a(x*)b")
	fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-", -1))
	fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-", -1))
	fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-axb-", -1))
	fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-ab-", -1))
}

11. unc (re *Regexp) MatchString(s string) bool

MatchString 报告 Regexp 是否匹配字符串 s 。

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile("(gopher){2}")
	fmt.Println(re.MatchString("gopher"))
	fmt.Println(re.MatchString("gophergopher"))
	fmt.Println(re.MatchString("gophergophergopher"))
}

12. func (re *Regexp) ReplaceAllString(src, repl string) string

ReplaceAllString 返回 src 的副本，用替换字符串 repl 替换正则表达式的匹配项。在内部 repl 中，$ 符号被解释为在 Expand 中，因此例如 $ 1 代表第一个子匹配的文本。

示例：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile("a(x*)b")
	fmt.Println(re.ReplaceAllString("-ab-axxb-", "T"))
	fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1"))
	fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1W"))
	fmt.Println(re.ReplaceAllString("-ab-axxb-", "${1}W"))
}

中文参考手册

持续更新中

lsron

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
GO:Regexp正则操作

概述正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。在go语言中，regexp 包实现正则表达式搜索。regexp接受通用的正则表达式语法，与Perl,Python和其他语言的语法相同，如果想查看golang正则表达式语法的详细概述,可以运行go命令：go doc regrexp/syntax附上正则表达式-语法教程常用方法参数说明：
复制链接

扫一扫