7.3 正则处理

正则表达式是一种进行模式匹配和文本操纵的复杂而又强大的工具。虽然正则表达式比纯粹的文本匹配效率低，但是它却更灵活。按照它的语法规则，随需构造出的匹配模式就能够从原始文本中筛选出几乎任何你想要得到的字符组合。如果你在Web开发中需要从一些文本数据源中获取数据,那么你只需要按照它的语法规则，随需构造出正确的模式字符串就能够从原数据源提取出有意义的文本信息。

Go语言通过regexp标准包为正则表达式提供了官方支持，如果你已经使用过其他编程语言提供的正则相关功能，那么你应该对Go语言版本的不会太陌生，但是它们之间也有一些小的差异，因为Go实现的是RE2标准，除了\C，详细的语法描述参考：http://code.google.com/p/re2/wiki/Syntax

其实字符串处理我们可以使用strings包来进行搜索(Contains、Index)、替换(Replace)和解析(Split、Join)等操作，但是这些都是简单的字符串操作，他们的搜索都是大小写敏感，而且固定的字符串，如果我们需要匹配可变的那种就没办法实现了，当然如果strings包能解决你的问题，那么就尽量使用它来解决。因为他们足够简单、而且性能和可读性都会比正则好。

如果你还记得，在前面表单验证的小节里，我们已经接触过正则处理，在那里我们利用了它来验证输入的信息是否满足某些预设的条件。在使用中需要注意的一点就是：所有的字符都是UTF-8编码的。接下来让我们更加深入的来学习Go语言的regexp包相关知识吧。

通过正则判断是否匹配

regexp包中含有三个函数用来判断是否匹配，如果匹配返回true，否则返回false

  2. func Match(pattern string, b []byte) (matched bool, error error)
  3. func MatchReader(pattern string, r io.RuneReader) (matched bool, error error)
  4. func MatchString(pattern string, s string) (matched bool, error error)

上面的三个函数实现了同一个功能，就是判断pattern是否和输入源匹配，匹配的话就返回true，如果解析正则出错则返回error。三个函数的输入源分别是byte slice、RuneReader和string。

如果要验证一个输入是不是IP地址，那么如何来判断呢？请看如下实现

  2. func IsIP(ip string) (b bool) {
  3.     if m, _ := regexp.MatchString("^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}$", ip); !m {
  4.         return false
  5.     }
  6.     return true
  7. }

可以看到，regexp的pattern和我们平常使用的正则一模一样。再来看一个例子：当用户输入一个字符串，我们想知道是不是一次合法的输入：

  2. func main() {
  3.     if len(os.Args) == 1 {
  4.         fmt.Println("Usage: regexp [string]")
  5.         os.Exit(1)
  6.     } else if m, _ := regexp.MatchString("^[0-9]+$", os.Args[1]); m {
  7.         fmt.Println("数字")
  8.     } else {
  9.         fmt.Println("不是数字")
  10.     }
  11. }

在上面的两个小例子中，我们采用了Match(Reader|String)来判断一些字符串是否符合我们的描述需求，它们使用起来非常方便。

通过正则获取内容

Match模式只能用来对字符串的判断，而无法截取字符串的一部分、过滤字符串、或者提取出符合条件的一批字符串。如果想要满足这些需求，那就需要使用正则表达式的复杂模式。

我们经常需要一些爬虫程序，下面就以爬虫为例来说明如何使用正则来过滤或截取抓取到的数据：

  2. package main
  4. import (
  5.     "fmt"
  6.     "io/ioutil"
  7.     "net/http"
  8.     "regexp"
  9.     "strings"
  10. )
  12. func main() {
  13.     resp, err := http.Get("http://www.baidu.com")
  14.     if err != nil {
  15.         fmt.Println("http get error.")
  16.     }
  17.     defer resp.Body.Close()
  18.     body, err := ioutil.ReadAll(resp.Body)
  19.     if err != nil {
  20.         fmt.Println("http read error")
  21.         return
  22.     }
  24.     src := string(body)
  26.     //将HTML标签全转换成小写
  27.     re, _ := regexp.Compile("\\<[\\S\\s]+?\\>")
  28.     src = re.ReplaceAllStringFunc(src, strings.ToLower)
  30.     //去除STYLE
  31.     re, _ = regexp.Compile("\\<style[\\S\\s]+?\\</style\\>")
  32.     src = re.ReplaceAllString(src, "")
  34.     //去除SCRIPT
  35.     re, _ = regexp.Compile("\\<script[\\S\\s]+?\\</script\\>")
  36.     src = re.ReplaceAllString(src, "")
  38.     //去除所有尖括号内的HTML代码，并换成换行符
  39.     re, _ = regexp.Compile("\\<[\\S\\s]+?\\>")
  40.     src = re.ReplaceAllString(src, "\n")
  42.     //去除连续的换行符
  43.     re, _ = regexp.Compile("\\s{2,}")
  44.     src = re.ReplaceAllString(src, "\n")
  46.     fmt.Println(strings.TrimSpace(src))
  47. }

从这个示例可以看出，使用复杂的正则首先是Compile，它会解析正则表达式是否合法，如果正确，那么就会返回一个Regexp，然后就可以利用返回的Regexp在任意的字符串上面执行需要的操作。

解析正则表达式的有如下几个方法：

  2. func Compile(expr string) (*Regexp, error)
  3. func CompilePOSIX(expr string) (*Regexp, error)
  4. func MustCompile(str string) *Regexp
  5. func MustCompilePOSIX(str string) *Regexp

CompilePOSIX和Compile的不同点在于POSIX必须使用POSIX语法，它使用最左最长方式搜索，而Compile是采用的则只采用最左方式搜索(例如[a-z]{2,4}这样一个正则表达式，应用于”aa09aaa88aaaa”这个文本串时，CompilePOSIX返回了aaaa，而Compile的返回的是aa)。前缀有Must的函数表示，在解析正则语法的时候，如果匹配模式串不满足正确的语法则直接panic，而不加Must的则只是返回错误。

在了解了如何新建一个Regexp之后，我们再来看一下这个struct提供了哪些方法来辅助我们操作字符串，首先我们来看下面这些用来搜索的函数：

  2. func (re *Regexp) Find(b []byte) []byte
  3. func (re *Regexp) FindAll(b []byte, n int) [][]byte
  4. func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
  5. func (re *Regexp) FindAllString(s string, n int) []string
  6. func (re *Regexp) FindAllStringIndex(s string, n int) [][]int
  7. func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string
  8. func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
  9. func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
  10. func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
  11. func (re *Regexp) FindIndex(b []byte) (loc []int)
  12. func (re *Regexp) FindReaderIndex(r io.RuneReader) (loc []int)
  13. func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int
  14. func (re *Regexp) FindString(s string) string
  15. func (re *Regexp) FindStringIndex(s string) (loc []int)
  16. func (re *Regexp) FindStringSubmatch(s string) []string
  17. func (re *Regexp) FindStringSubmatchIndex(s string) []int
  18. func (re *Regexp) FindSubmatch(b []byte) [][]byte
  19. func (re *Regexp) FindSubmatchIndex(b []byte) []int

上面这18个函数我们根据输入源(byte slice、string和io.RuneReader)不同还可以继续简化成如下几个，其他的只是输入源不一样，其他功能基本是一样的：

  2. func (re *Regexp) Find(b []byte) []byte
  3. func (re *Regexp) FindAll(b []byte, n int) [][]byte
  4. func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
  5. func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
  6. func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
  7. func (re *Regexp) FindIndex(b []byte) (loc []int)
  8. func (re *Regexp) FindSubmatch(b []byte) [][]byte
  9. func (re *Regexp) FindSubmatchIndex(b []byte) []int

对于这些函数的使用我们来看下面这个例子

  2. package main
  4. import (
  5.     "fmt"
  6.     "regexp"
  7. )
  9. func main() {
  10.     a := "I am learning Go language"
  12.     re, _ := regexp.Compile("[a-z]{2,4}")
  14.     //查找符合正则的第一个
  15.     one := re.Find([]byte(a))
  16.     fmt.Println("Find:", string(one))
  18.     //查找符合正则的所有slice,n小于0表示返回全部符合的字符串，不然就是返回指定的长度
  19.     all := re.FindAll([]byte(a), -1)
  20.     fmt.Println("FindAll", all)
  22.     //查找符合条件的index位置,开始位置和结束位置
  23.     index := re.FindIndex([]byte(a))
  24.     fmt.Println("FindIndex", index)
  26.     //查找符合条件的所有的index位置，n同上
  27.     allindex := re.FindAllIndex([]byte(a), -1)
  28.     fmt.Println("FindAllIndex", allindex)
  30.     re2, _ := regexp.Compile("am(.*)lang(.*)")
  32.     //查找Submatch,返回数组，第一个元素是匹配的全部元素，第二个元素是第一个()里面的，第三个是第二个()里面的
  33.     //下面的输出第一个元素是"am learning Go language"
  34.     //第二个元素是" learning Go "，注意包含空格的输出
  35.     //第三个元素是"uage"
  36.     submatch := re2.FindSubmatch([]byte(a))
  37.     fmt.Println("FindSubmatch", submatch)
  38.     for _, v := range submatch {
  39.         fmt.Println(string(v))
  40.     }
  42.     //定义和上面的FindIndex一样
  43.     submatchindex := re2.FindSubmatchIndex([]byte(a))
  44.     fmt.Println(submatchindex)
  46.     //FindAllSubmatch,查找所有符合条件的子匹配
  47.     submatchall := re2.FindAllSubmatch([]byte(a), -1)
  48.     fmt.Println(submatchall)
  50.     //FindAllSubmatchIndex,查找所有字匹配的index
  51.     submatchallindex := re2.FindAllSubmatchIndex([]byte(a), -1)
  52.     fmt.Println(submatchallindex)
  53. }

前面介绍过匹配函数，Regexp也定义了三个函数，它们和同名的外部函数功能一模一样，其实外部函数就是调用了这Regexp的三个函数来实现的：

  2. func (re *Regexp) Match(b []byte) bool
  3. func (re *Regexp) MatchReader(r io.RuneReader) bool
  4. func (re *Regexp) MatchString(s string) bool

接下里让我们来了解替换函数是怎么操作的？

  2. func (re *Regexp) ReplaceAll(src, repl []byte) []byte
  3. func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
  4. func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte
  5. func (re *Regexp) ReplaceAllLiteralString(src, repl string) string
  6. func (re *Regexp) ReplaceAllString(src, repl string) string
  7. func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string

这些替换函数我们在上面的抓网页的例子有详细应用示例，

接下来我们看一下Expand的解释：

  2. func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
  3. func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte

那么这个Expand到底用来干嘛的呢？请看下面的例子：

  2. func main() {
  3.     src := []byte(`
  4.         call hello alice
  5.         hello bob
  6.         call hello eve
  7.     `)
  8.     pat := regexp.MustCompile(`(?m)(call)\s+(?P<cmd>\w+)\s+(?P<arg>.+)\s*$`)
  9.     res := []byte{}
  10.     for _, s := range pat.FindAllSubmatchIndex(src, -1) {
  11.         res = pat.Expand(res, []byte("$cmd('$arg')\n"), src, s)
  12.     }
  13.     fmt.Println(string(res))
  14. }

至此我们已经全部介绍完Go语言的regexp包，通过对它的主要函数介绍及演示，相信大家应该能够通过Go语言的正则包进行一些基本的正则的操作了。