go语言regexp go语言教程

go语言有支持正则表达式后向引用的方法吗

go语言有支持正则表达式后向引用的方法，方法如下

北票网站建设公司创新互联建站,北票网站设计制作，有大型网站制作公司丰富经验。已为北票超过千家提供企业网站建设服务。企业网站搭建\成都外贸网站建设要多少钱，请找那个售后服务好的北票做网站的公司定做！

package main

import (

"fmt"

"os"

"path/filepath"

"regexp"

)

func main() {

// 命令行参数

args := os.Args

// 检查参数

if len(args) == 1 {

fmt.Println("ff is a file find tool. use like bottom")

fmt.Println("ff [dir] [regexp]")

return

}

if len(args) 3 {

fmt.Println("args 3")

return

}

fileName := args[1]

pattern := args[2]

file, err := os.Open(fileName)

if err != nil {

fmt.Println(err)

return

}

fi, err := file.Stat()

if err != nil {

fmt.Println(err)

return

}

if !fi.IsDir() {

fmt.Println(fileName, " is not a dir")

}

reg, err := regexp.Compile(pattern)

if err != nil {

fmt.Println(err)

return

}

// 遍历目录

filepath.Walk(fileName,

func(path string, f os.FileInfo, err error) error {

if err != nil {

fmt.Println(err)

return err

}

if f.IsDir() {

return nil

}

// 匹配目录

matched := reg.MatchString(f.Name())

if matched {

fmt.Println(path)

}

return nil

})

}

golang 正则 regexp包使用

先介绍几种常用的方法：

1、使用MatchString函数或Match函数

regexp.MatchString(pattern string, s string) pattern为正则表达式，s为需要校验的字符串

regexp.Match(pattern string, b []byte) pattern为正则表达式，s为需要校验的字符串

它们的作用都是匹配，区别在于参数为字符串和切片

实例如下：

2、使用 Compile函数或MustCompile函数

它们的区别是Compile返回两个参数 Regexp,error类型，而MustCompile只返回 Regexp类型

它们的作用是将正则表达式进行编译，返回优化的 Regexp 结构体，该结构体有需多方法。

实例如下：

3、查找正则匹配字串（ 注：函数名包含string的所传参数为string 其他的均为[]byte 带All是所有）

查找正则匹配的字符串位置（ 注：函数名包含string的所传参数为string 其他的均为[]byte 带All是所有）

4、替换

正则替换

按原文替换

函数处理替换源字串

5、Regexp结构体中一些常用的方法

go语言递归扫描指定目录下文件

使用go语言递归查找指定目录下的文件，根据正则匹配筛选出需要的文件，并且忽略指定的目录

先使用 ioutil.ReadDir 遍历出指定目录下的文件，再递归进目录中遍历，问题的关键在于识别出文件为目录， fs.FileInfo 中有一个 IsDir() 函数可以识别是否是目录

正则匹配使用 regexp.MatchString ，regexp中有很多正则操作的工具，如根据正则替换字符串中的指定字符

golang正则表达式 分组命名

正则中有分组这个功能，在golang中也可以使用命名分组。

一次匹配的情况

场景还原如下：

有一行文本，格式为：姓名 年龄 邮箱地址

请将其转换为一个map

代码实现如下：

str := `Alice 20 alice@gmail.com`

// 使用命名分组，显得更清晰

re := regexp.MustCompile(`(?Pname[a-zA-Z]+)\s+(?Page\d+)\s+(?Pemail\w+@\w+(?:\.\w+)+)`)

match := re.FindStringSubmatch(str)

groupNames := re.SubexpNames()

fmt.Printf("%v, %v, %d, %d\n", match, groupNames, len(match), len(groupNames))

result := make(map[string]string)

// 转换为map

for i, name := range groupNames {

if i != 0 name != "" { // 第一个分组为空（也就是整个匹配）

result[name] = match[i]

}

}

prettyResult, _ := json.MarshalIndent(result, "", " ")

fmt.Printf("%s\n", prettyResult)

输出为：

[Alice 20 alice@gmail.com Alice 20 alice@gmail.com], [ name age email], 4, 4

{

"age": "20",

"email": "alice@gmail.com",

"name": "Alice"

}

注意 [ name age email]有4个元素， 第一个为""。

多次匹配的情况

接上面的例子，实现一个更贴近现实的需求：

有一个文件， 内容大致如下：

Alice 20 alice@gmail.com

Bob 25 bob@outlook.com

gerrylon 26 gerrylon@github.com

...

更多内容

和上面一样， 不过这次转出来是一个slice of map, 也就是多个map。

代码如下：

// 文件内容直接用字符串表示

usersStr := `

Alice 20 alice@gmail.com

Bob 25 bob@outlook.com

gerrylon 26 gerrylon@github.com

`

userRe := regexp.MustCompile(`(?Pname[a-zA-Z]+)\s+(?Page\d+)\s+(?Pemail\w+@\w+(?:\.\w+)+)`)

// 这里要用FindAllStringSubmatch，找到所有的匹配

users := userRe.FindAllStringSubmatch(usersStr, -1)

groupNames := userRe.SubexpNames()

var result []map[string]string // slice of map

// 循环所有行

for _, user := range users {

m := make(map[string]string)

// 对每一行生成一个map

for j, name := range groupNames {

if j != 0 name != "" {

m[name] = strings.TrimSpace(user[j])

}

}

result = append(result, m)

}

prettyResult, _ := json.MarshalIndent(result, "", " ")

fmt.Println(string(prettyResult))

输出为：

[

{

"age": "20",

"email": "alice@gmail.com",

"name": "Alice"

},

{

"age": "25",

"email": "bob@outlook.com",

"name": "Bob"

},

{

"age": "26",

"email": "gerrylon@github.com",

"name": "gerrylon"

}

]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

总结

使用命名分组可以使正则表示的意义更清晰。

转换为map更加符合人类的阅读习惯，不过比一般的根据索引取分组值麻烦一些。

————————————————

版权声明：本文为CSDN博主「butterfly5211314」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：

golang 正则正则表达式反向查询

基本上所有的语言都有正则表达式，golang也不例外。golang原生使用regexp包进行正则表达式的匹配。正常情况下满足基础的查询功能。但是，golang为了正则表达式的效率一直坚持O(n)的搜索复杂度，所以有些高级特性将无法满足。

正则表达式可以通过\1的形式反向查询之前匹配的数据,但是原生自带的regxp是不支持该特性。所以只能使用第三方库来支持。