正则表达式语法概述(熟悉可跳过)

go doc regexp/syntax

单字符集

复合

重复

分组

标志(Flags)

零宽度字符串

转义序列

字符集元素

被命名的字符集作字符集元素

Perl字符集(ASCII Only)

ASCII字符集

Regexp

Find(All)?(String)?(Submatch)?(Index)?

匹配

Example

package main

import (
	"regexp"
	"fmt"
)

func checkError(err error) {
	if err != nil {
		panic(err)
	}
}

func main() {
	pattern := `[0-9]{6,11}`
	tb := []byte("520912345")
	matched, err := regexp.Match(pattern, tb)
	checkError(err)
	fmt.Println(matched) // true
	matched, err = regexp.MatchString(pattern, "1977")
	checkError(err)
	fmt.Println(matched) // false
}

预编译正则表达式

Example

package main

import (
	"regexp"
	"fmt"
)

func main() {
	re := regexp.MustCompile(`a.*?a`)
	text := []byte("aabbaa")
	finded := re.FindAll(text, -1)
	fmt.Printf("%q\n", finded) //["aa", "aa"]
	lre := regexp.MustCompilePOSIX(`a.*?a`) // ["aabbbaa"]
	finded = lre.FindAll(text, -1)
	fmt.Printf("%q\n", finded)
}

查找

package main

import (
	"regexp"
	"fmt"
)

func main() {
	expr := `(\d{4})-(\d{3})-(\d{4})`
	text := []byte("1231-456-45631245-123-0012")
	re := regexp.MustCompile(expr)
	finded := re.Find(text)
	fmt.Printf("%s\n", finded)
	allfinded := re.FindAll(text, -1)
	fmt.Printf("%s\n", allfinded)
	submatch := re.FindSubmatch(text)
	fmt.Printf("%s\n", submatch)
	allsubmatch := re.FindAllSubmatch(text, -1)
	fmt.Printf("%s\n", allsubmatch)
	index := re.FindIndex(text)
	fmt.Printf("%d\n", index)
	allindex := re.FindAllIndex(text, -1)
	fmt.Printf("%d\n", allindex)
	submatchIndex := re.FindSubmatchIndex(text)
	fmt.Printf("%d\n", submatchIndex)
	allSubmatchIndex := re.FindAllSubmatchIndex(text, -1)
	fmt.Printf("%d\n", allSubmatchIndex)
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	expr := `\d{3}-\d{4}-\d{3}`
	text := []byte("123-1234-5671-1234-123")
	re := regexp.MustCompile(expr)
	/*
		实际输出:[123-1234-567]
		而这里结果不是 [123-1234-567, 671-1234-123]
		是因为"67"匹配后就被"吃"了
	*/
	all := re.FindAll(text, -1)
	fmt.Printf("%s\n", all)
}

替换

Example

package main

import (
	"fmt"
	"regexp"
	"bytes"
)

func main() {
	expr := `\b(?P<begin>\w+)\b \b(\w+)\b \b(?P<end>\w+)\b`
	text := []byte("Hello Marco Epsilon")
	re := regexp.MustCompile(expr)
	replace := []byte("$end $2 $begin")
	replaced := re.ReplaceAll(text, replace)
	// Output: Epsilon Marco Hello
	fmt.Printf("%s\n", replaced)
	// add func to lowercase first alpha,without using expand
	funced := re.ReplaceAllFunc(text, func(repl []byte) []byte {
		return bytes.ToLower(repl)
	})
	// Output: hello marco epsilon
	fmt.Printf("%s\n", funced)
	// keep $3 $2 $1 because of literal,without using expand
	literaled := re.ReplaceAllLiteral(text, []byte("$3 $2 $1"))
	fmt.Printf("%s\n", literaled)
}

组合

package main

import (
	"fmt"
	"regexp"
)

func main() {
	expr := `(?m)(?P<key>\w+):\s(?P<value>\w+)$`
	re := regexp.MustCompile(expr)
	text := []byte(`
		optional1: content1
		optional2: content2
		optional3: content3
	`)
	dst := []byte{}
	template := []byte("$key=$value\n")
	allIndex := re.FindAllSubmatchIndex(text, -1)
	for _, index := range allIndex {
		dst = re.Expand(dst, template, text, index)
	}
	/*
	Output:
		optional1=content1
		optional2=content2
		optional3=content3
	*/
	fmt.Printf("%s", dst)
}

More Functions

package main

import (
	"regexp"
	"fmt"
)

func main() {
	expr := `hello,this is literal,next is not\d{3}`
	re := regexp.MustCompile(expr)
	literal, completed := re.LiteralPrefix()
	// Output:
	// hello,this is literal,next is not
	// false
	fmt.Println(literal)
	fmt.Println(completed)
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	// leftmost-first mode
	expr := `(?U)a.*b`
	text := []byte("abaaaab")
	re := regexp.MustCompile(expr)
	// Output:
	// [ab aaaab]
	fmt.Printf("%s\n", re.FindAll(text, -1))
	// leftmost-longest mode
	re.Longest()
	// Output:
	// [abaaaab]
	fmt.Printf("%s\n", re.FindAll(text, -1))
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	expr := `((\d{3})haha\d{2}){4}`
	re := regexp.MustCompile(expr)
	// Output:
	// 2
	fmt.Println(re.NumSubexp())
}

package main

import (
	"fmt"
	"regexp"
)

func main() {
	expr := `ab|bc`
	re := regexp.MustCompile(expr)
	text := "cbabcbdebacbcabcbbacb"
	results := re.Split(text, -1)
	for _, value := range results {
		fmt.Println(value)
	}
	fmt.Println("-----------")
	results = re.Split(text, 3)
	for _, value := range results {
		fmt.Println(value)
	}
	// Output:
	/*
	cb
	cbdebac

	cbbacb
	-----------
	cb
	cbdebac
	abcbbacb
	*/
}

package main

import (
	"regexp"
	"fmt"
)

func main() {
	expr := `ab|bc\d{2,5}`
	re := regexp.MustCompile(expr)
	fmt.Println(re.String())
	//Output: ab|bc\d{2,5}
}

package main

import (
	"regexp"
	"fmt"
)

func main() {
	expr := `(?P<name>[^:]+):\s+(.*),\s+(?P<age>[^:]+):\s+(.*)`
	re := regexp.MustCompile(expr)
	names := re.SubexpNames()
	for _, v := range names {
		fmt.Println(v)
	}
	//Output:
	/*
	
	name

	age

	*/
}