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

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

10年积累的网站制作、网站建设经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有城子河免费网站建设让你可以放心的选择与我们合作。

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正则表达式 分组命名

正则中有分组这个功能，在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版权协议，转载请附上原文出处链接及本声明。

原文链接：

Python开发者在转到Go语言之前需要了解什么？

转载请参见文章末尾处的要求。【感谢张佳伟（@ghosert）的热心翻译。如果其他朋友也有不错的原创或译文，可以尝试推荐给伯乐在线。】这是一篇（长）博文， 介绍了我们在 Repustate 迁移大量 Python/Cython 代码到 Go 语言的经验。如果你想了解整个故事，背景和所有的事情，请继续往下读。如果你只是想了解 Python 开发者在一头扎进 Go 语言前需要了解什么，请点击一下链接：从Python迁移到Go的建议(Tips Tricks) 背景在Repustate，我们完成过的最棒的技术成就之一是实现了阿拉伯语的情感分析。阿拉伯语是一块难啃的硬骨头，因为它的词形变化相当复杂。比起譬如英语，阿拉伯语的分词（将一个句子切分呈几个独立的单词）也更困难，因为阿拉伯语的单词本身还可能会包含空白字符（例如：“阿列夫”在一个单词里的位置）。这也谈不上是泄密，Repustate 使用支持向量机（SVM）来获取一个句子背后最有可能的含义，并在其中加上情感元素。 总体上来说，我们使用了 22 种模型（22 个 SVM） 并且在一篇文档中，每一个单词我们都会加以分析。因此如果你有一篇 500 字的文档，那么基于 SVM，会进行十万次的比较。 PythonRepustate 几乎完全就是一个 Python 商店。我们使用 Django 来实现 API 和网站。因此（目前）为了保持代码一致，同时使用 Python 来实现阿拉伯语情感引擎是合情合理的。只是做原型和实现的话，Python 是很好的选择。它的表达能力很强悍，第三方类库等等也很好。如果你就是为了Web服务，Python 很完美。但是当你进行低级别的计算，大量依赖于哈希表（Python 里的字典类型）做比较的时候，一切都变慢了。我们每秒能处理大约两到三个阿拉伯文档，但是这太慢了。比较下来，我们的英语情感引擎每秒能处理大约五百份文档。 瓶颈因此我们开启了 Python 分析器，开始调查是什么地方用了那么长时间。还记得我前面说过我们有 22 个 SVM 并且每个单词都需要经过处理吗？好吧，这些都是线性处理的，非并行处理。所以我们的第一反应是把线性处理改成 map/reduce 那样的操作。简单来说：Python 不太适合用作 map/reduce。当你需要并发的时候，Python 算上好用。在 2013 Python 大会上（译者：PyCon 2013），Guido 谈到了 Tulip，他的这个新项目正在弥补 Python 这方面的不足，不过得过段一段时间才能推出，但是如果已经有了更好用的东西，我们为什么还要等呢？ 选Go 语言，还是回家算了？我在Mozilla的朋友告诉我，Mozilla 内部正在将他们大量的基础日志架构切换到 Go 语言上，部分原因是因为强大的 [goroutines]。Go 语言是 Google 的人设计的，并且在设计之初就把支持并发作为第一要务，而不是像 Python 的各种解决方案那样是事后才加上去的。因此我们开始着手把 Python 换成 Go 语言。虽然Go 代码还不算正式上线的产品，但是结果非常令人鼓舞。我们现在能做到每秒处理一千份文档，使用更少的内存，还不用调试你在 Python 里遇到：丑陋的多进程/gevent/“为什么 Control-C 杀不了进程”这些问题。 为什么我们喜欢 Go 语言任何人，对编程语言是如何工作（解释型 vs 编译型， 动态语言 vs 静态语言）有一点理解的话，会说，“切，当然 Go 语言会更快”。是的，我们也可以用 Java 把所有的东西重写一遍，也能看到类似更快的改善，但那不是 Go 语言胜出的原因。你用 Go 写的代码好像就是对的。我搞不清楚到底是怎么回事，但是一旦代码被编译了（编译速度很快），你就会觉得这代码能工作（不只是跑起来不会错，而且甚至逻辑上也是对的）。我知道，这听上去不太靠谱，但是确实如此。这和 Python 在冗余（或非冗余）方面非常类似，它把函数作为第一目标，因此函数编程会很容易想明白。而且当然，go 线程和通道让你的生活更容易，你可以得到静态类型带来的性能大提升，还能更精细的控制内存分配，而你却不必为此在语言表达力上付出太多的代价。 希望能早点知道的事情（Tips Tricks）除去所有这些赞美之词以后，有时你真的需要在处理 Go 代码的时候，相对于 Python，改变一下思维方式。因此这是我在迁移代码时记录的笔记清单 —— 只是在我把 Python 代码转换到 Go 时从我脑子里随机冒出来的点子：没有内建的集合类型（必须使用map，并检查是否存在）因为没有集合，必须自己写交集，并集之类的方法没有tuples 类型，必须写你自己的结构，或者使用 slices （即数组）没有类似 \__getattr__() 的方法，你必须总是检查存在性，而不是设置默认值，例如，在 Python 里，你可以这样写 value = dict.get(“a_key”, “default_value”)必须总是检查错误（或者显式的忽略错误）不能有变量/包没被使用，因此简单的测试也需要有时注掉一些代码在[] byte 和 string 之间转换。 regexp 使用 [] byte （不可变）。这是对的，但是老把一些变量转换来转换去很烦人Python 更宽松。你可以使用超出范围的索引在字符串里取一个片段，而且不会出错。你还可以用负数取出片段，但是 Go 不行你不能混合数据结构类型。也许这样也不太干净，但是有时在 Python 里，我会使用值是混合了字符串和列表的字典。但是 Go 不行，你不得不清理干净你的数据结构或者使用自定义的结构不能解包一个 tuple 或者 list 到几个不同的变量（例如：x, y, z = [1, 2, 3]）驼峰式命名风格（如果你没有首字大写方法名/结构名，他们不会被暴露给其它的包）。我更喜欢 Python 的小写字母加下划线命名风格。必须显式检查是否有错误 != nil, 不像在 Python 里，许多类型可以像 bool 那样检查 （0, “”, None 都可以被解释成 “非” 集合）文档在一些模块上太散乱了，例如（crypto/md5），但是 IRC 上的 go-nuts 很好用，提供了巨大的帮助。从数字到字符串的转换（int64 - string） 和 []byte - string （只要使用 string([]byte)）不太一样。需要使用 strconv。阅读Go 代码比起 Python 那样写起来如伪代码的语言更像一门编程语言， Go 有更多的非字母数字字符，并且使用 || 和 ， 而不是 “or”和“and”写一个文件的话，有 File.Write([]byte) 和 File.WriteString(string)， 这点和 Python 开发者的 Python 之道：“解决问题就一种方法 ”相违背。修改字符串很困难，必须经常重排 fmt.Sprintf没有构造函数，因此惯用法是创建 NewType() 方法来返回你要的结构Else （或者 else if）必须正确格式化，else 得和 if 配对的大括号在同一行。奇怪。赋值运算符取决于在函数内还是函数外，例如，= 和 :=如果我只想要“键”或者只想要 “值”，譬如： dict.keys() 或者 dict.values()，或者一个 tuples 的列表，例如：dict.items()，在 Go 语言里没有等价的东西，你只能自己枚举 map 来构造你的列表类型我有时使用一种习惯用法：构造一个值是函数的字典类型，我想通过给定的键值调用这些函数，你在 Go 里可以做到，但是所有的函数必须接受，返回相同的东西，例如：相同的方法签名如果你使用 JSON 并且 你的 JSON 是一个复合类型，恭喜你。 你必须构造自定义的结构匹配 JSON 块里的格式，然后把原始 JSON 解析到你自定义结构的实例中去。比起 Python 世界里 object = json.loads(json_blob) 要做更多的工作 是不是值得？值得，一百万倍的值得。速度的提升太多了，以致很难舍弃。同时，我认为， Go 是目前趋势所在，因此在招新员工的时候，我认为把 Go 当作 Repustate 技术积累的重要一环会很有帮助。]

Python 开发者在迁移到 Go 时需要知道哪些事

这是一篇讲述将大块 Python/Cython 代码迁移到 Go 的长文章。如果你想了解整个事情的经过、背景等所有信息，请读下去。如果你只对 Python 开发者需要了解的事感兴趣，请下拉到早该知道的事板块。

背景

我们在 Repustate 最大的技术成果就是实现了阿拉伯语情感分析。阿拉伯语是个难啃的硬骨头，因为阿拉伯语词汇的形式非常复杂。阿拉伯语的标记化（把一句话拆分成单个单词）也比英语要难得多，因为阿拉伯单词内部可能会包含空格（例如单词内部“aleph”的位置）。在不泄露机密的情况下，Repustate 利用支持向量机（SVM）来获取一个句子最可能的意思，并且以此来推断句子的情感。我们一共采用了22种模型（22个支持向量机），文档中的每个词都会被分析。也就是说，如果一个文档包含500个词，就会与支持向量机进行10000多次对比。

Python

Repustate 几乎完全是用 Python 搭建的，我们使用 Django 来搭建 API 接口和网站架构。因此，为了保持代码一致性，使用 Python 来实现所有阿拉伯语情感引擎才说得通。就原型设计和实现流程而言，Python 依然是一个很好的选择：表现能力优秀，又有强大的第三方库资源，等等。如果是服务于网页，它就是最佳选择。如果是稍低级别的运算，需要与哈希表（Python 中的字典）进行大量对比时，运行速度就会慢下来。我们一秒钟只能处理2到3个阿拉伯语单词，这种速度太慢了。相比之下，我们的英语情感引擎每秒能处理500个单词。

瓶颈

因此，我们启动了 Python 分析器，开始调查速度慢的原因。还记得上文提到我们有22个支持向量机，每个单词都会通过它们处理吗？原来这个过程是按顺序进行，而不是并行的。好了，第一个想法是换成类似分布式计算系统（map/reduce）的处理器。长话短说：Python 不适合用 map/reduce。当你需要并发性的时候，Python 并不能帮上忙。在 Pycon 2013大会中，Guido 谈到了 Tulip，他希望用来解决这个问题的一个新项目，但是还要过一段时间才能发布。可是，如果已经有了更好的选择，为什么还要苦等下去呢？

选择 Golang 还是回老家(Go Home)

在 Mozilla 的朋友告诉笔者，Mozilla 服务的日志架构大部分代码都已迁移到 Go，部分原因是 goroutines 超级便利。Go 是由谷歌员工开发的，设计之初就将并发需求列为一级理念，而不是像 Python 的众多解决方案一样在做事后补救。因此我们开始着手实现从 Python 到 Go 的迁移。

虽然 Go 代码还没实现大规模产出，得到的结果已经非常振奋人心。我们现在一秒钟能处理1000个文档，使用的内存大大减少，而且也不用再去调试和解决使用 Python 时会遇到的多进程/协程（gevent）/“为什么 Control-C 杀死了我的进程”等问题。

喜欢 Go 的原因

任何略懂编程语言的人（明白解释与编译、动态与静态区别）都会说：“哈，显然 Go 要快多了。”没错，我们是可以用 Java 重写所有内容，并且取得类似的效果，但是这并不是 Go 胜出的原因。你用 Go 写的代码似乎一出来是正确的。笔者也说不清楚，但是不知怎么的，一旦代码被编译（编译过程非常迅速），你就会感觉它能工作了（不只是运行不出错，而且还逻辑正确）。这听起来很含糊，但是它是真的。在冗余或无冗余方面，它跟 Python 相似，它把函数当做一级对象，因此函数编程很方便。而且毋庸置疑，goroutines 和 channels 会让你更加省心省力。静态类型还会带来极大的性能提升，以及更精确的内存分配控制，但是又不会损失太多表达性。

早该知道的事

除去溢美之词，跟 Go 打交道需要与 Python 完全不同的一套思维模式。以下列出的是笔者在迁移时做的一些笔记——都是在从 Python 迁移到 Go 时随机想到的一些东西：

没有内建的集合类型（需要使用 map，然后测试存在性）

由于没有集合类型，需要自己写代码来实现交集、并集等方法

无元组（tuple），必须自己写架构或使用切片（slice）（数组）

没有类似 getattr_() 的方法，因此需要不断检查存在性，而不能像在 Python 中那样设置缺省值：value = dict.get(“a_key”, “default_value”)

必须不断检查错误（至少需要显式忽略它们）

不能包含未使用的变量或包，因此有时候如果要测试一些简单问题，需要给代码添加注释

在 []byte 和 string 之间切换。正则表达 （regexp） 使用 []byte （可变）。这说得通，但是在一些变量之间来回切换还是很烦人

Python 更为宽松。你可以用超出范围的索引来索取字符串片段，也不会有什么问题，还可以提取负值片段，但是 Go 就不行

不能使用混合类型的数据结构。也许不合规定，但是有时候在 Python 可以使用混合字符串和列表的字典。在 Go 就不行，要么清理干净数据结构，要么自定义结构。感谢 Ralph Corderoy 向笔者展示了如何正确操作（用这个界面，卢克）

不能把元组或列表分解成分开的变量（如 x,y,x = [1,2,3]）

驼峰字规则（UpperCamelCase）（如果一个包中的函数或结构首字母未大写，就不会暴露给其他包）。笔者更喜欢 Python 的小写加下划线格式（lower_case_with_underscores）

需要显式检查错误是否为 != nil，不像 Python 有很多类型可以用于布尔型检查（0，“”，None 都会被解读为“假”）

某些模块（如 crypto/md5）的文档不足，但是 IRC 上面的 go-nuts 非常棒，拥有特别好的支持

从数字到字符串的类型转换（int64 - 字符串）跟[]byte - 字符串（只用字符串（[]byte））不同，需要用到 strconv

Go 的代码读起来更像是编程语言，而 Python写出来更像伪代码。Go 包含更多非数字字母字符，用 || 和 来表示“或”与“和”

写文件会有 File.Write([]byte) 和File.WriteString(string)，这会让习惯了 Python

只有一种做事方法的开发者们有些不适应

字符串插入很麻烦，不得不经常使用 fmt.Sprintf

没有构造函数，常见的做法是创建 NewType() 函数，来返回你需要的结构

Else 或 else if 必须格式正确，else 得跟 if 从句的大括号在一行。这很奇怪。

根据函数内外位置，使用不同的赋值操作符，例如 = 和 :=

如果只想要类似dict.keys() 或dict.values()得到的键值或取值列表，或者通过

dict.items()得到的元祖列表，在 Go 里面是无法实现的，只能自行迭代 map，然后创建自己的列表

笔者习惯建立一个取值为函数的字典，并通过键值调用函数。你可以在 Go

里面这么做，但是所有的函数都得接受和返回同样的东西，也就是说，必须具备同样的方法签名

如果你是用 JSON， 而且是混合类型的 JSON，那么你还是自求多福吧。你得创建一个能够匹配你的 JSON 二进制大对象（blob）格式的个性化结构，然后解组（Unmarshall）原始 JSON 成为你的个性化架构的一个用例。比起在 Python 中的一句“obj = json.loads(json_blob)”要费更多功夫

这么折腾值得吗？

值，一百万个值，超值。速度的提升不容忽视。而且笔者认为这也是促使 Go 成为流行语言的重要原因。因此在招聘时，笔者认为把 Go 当成 Python 开发者的必备技能也很重要。

golang sync.pool对象复用 并发原理 缓存池

在go http每一次go serve(l)都会构建Request数据结构。在大量数据请求或高并发的场景中，频繁创建销毁对象，会导致GC压力。解决办法之一就是使用对象复用技术。在http协议层之下，使用对象复用技术创建Request数据结构。在http协议层之上，可以使用对象复用技术创建(w,*r,ctx)数据结构。这样即可以回快TCP层读包之后的解析速度，也可也加快请求处理的速度。

先上一个测试：

结论是这样的：

貌似使用池化，性能弱爆了？？？这似乎与net/http使用sync.pool池化Request来优化性能的选择相违背。这同时也说明了一个问题，好的东西，如果滥用反而造成了性能成倍的下降。在看过pool原理之后，结合实例，将给出正确的使用方法，并给出预期的效果。

sync.Pool是一个 协程安全 的 临时对象池 。数据结构如下：

local 成员的真实类型是一个 poolLocal 数组，localSize 是数组长度。这涉及到Pool实现，pool为每个P分配了一个对象，P数量设置为runtime.GOMAXPROCS(0)。在并发读写时，goroutine绑定的P有对象，先用自己的，没有去偷其它P的。go语言将数据分散在了各个真正运行的P中，降低了锁竞争，提高了并发能力。

不要习惯性地误认为New是一个关键字，这里的New是Pool的一个字段，也是一个闭包名称。其API：

如果不指定New字段，对象池为空时会返回nil，而不是一个新构建的对象。Get()到的对象是随机的。

原生sync.Pool的问题是，Pool中的对象会被GC清理掉，这使得sync.Pool只适合做简单地对象池，不适合作连接池。

pool创建时不能指定大小，没有数量限制。pool中对象会被GC清掉，只存在于两次GC之间。实现是pool的init方法注册了一个poolCleanup()函数，这个方法在GC之前执行，清空pool中的所有缓存对象。

为使多协程使用同一个POOL。最基本的想法就是每个协程，加锁去操作共享的POOL，这显然是低效的。而进一步改进，类似于ConcurrentHashMap（JDK7）的分Segment，提高其并发性可以一定程度性缓解。

注意到pool中的对象是无差异性的，加锁或者分段加锁都不是较好的做法。go的做法是为每一个绑定协程的P都分配一个子池。每个子池又分为私有池和共享列表。共享列表是分别存放在各个P之上的共享区域，而不是各个P共享的一块内存。协程拿自己P里的子池对象不需要加锁，拿共享列表中的就需要加锁了。

Get对象过程：

Put过程：

如何解决Get最坏情况遍历所有P才获取得对象呢：

方法1止前sync.pool并没有这样的设置。方法2由于goroutine被分配到哪个P由调度器调度不可控，无法确保其平衡。

由于不可控的GC导致生命周期过短，且池大小不可控，因而不适合作连接池。仅适用于增加对象重用机率，减少GC负担。2

执行结果:

单线程情况下，遍历其它无元素的P，长时间加锁性能低下。启用协程改善。

结果：

测试场景在goroutines远大于GOMAXPROCS情况下，与非池化性能差异巨大。

测试结果

可以看到同样使用*sync.pool，较大池大小的命中率较高，性能远高于空池。

结论：pool在一定的使用条件下提高并发性能，条件1是协程数远大于GOMAXPROCS，条件2是池中对象远大于GOMAXPROCS。归结成一个原因就是使对象在各个P中均匀分布。

池pool和缓存cache的区别。池的意思是，池内对象是可以互换的，不关心具体值，甚至不需要区分是新建的还是从池中拿出的。缓存指的是KV映射，缓存里的值互不相同，清除机制更为复杂。缓存清除算法如LRU、LIRS缓存算法。

池空间回收的几种方式。一些是GC前回收，一些是基于时钟或弱引用回收。最终确定在GC时回收Pool内对象，即不回避GC。用java的GC解释弱引用。GC的四种引用：强引用、弱引用、软引用、虚引用。虚引用即没有引用，弱引用GC但有空间则保留，软引用GC即清除。ThreadLocal的值为弱引用的例子。

regexp 包为了保证并发时使用同一个正则，而维护了一组状态机。

fmt包做字串拼接，从sync.pool拿[]byte对象。避免频繁构建再GC效率高很多。

当前名称：go语言regexp,go语言适合做什么
当前网址：http://kswjz.com/article/dscpede.html