文章目录
-
- 1 regexp.Match
- 2 regexp.MatchReader()
- 3 regexp.MatchString()
- 4 regexp.QuoteMeta
- 5 regexp.Compile()创建 Regexp 对象
- 6 regexp.CompilePOSIX()创建regexp对象
- 7 regexp.MustCompile创建regexp对象
- regexp.MustCompilePOSIX()创建对象
- 8 Find()方法
- FindString()方法
- 9 FindAll()方法
- 10 FindAllString()方法
- 11 FindIndex()方法
- 12 FindStringIndex()方法
- 13 FindReaderIndex()方法
- 14 FindAllIndex()方法
- 15 FindAllStringIndex()方法
1 regexp.Match
判断在 b 中能否找到正则表达式 pattern 所匹配的子串
func Match(pattern string, b []byte) (matched bool, err error)
- pattern：要查找的正则表达式
- b：要在其中进行查找的 []byte
- matched：返回是否找到匹配项
- err：返回查找过程中遇到的任何错误
package main
import (
"regexp"
"fmt"
)
func main() {
fmt.Println(regexp.Match("H.* ", []byte("Hello World!")))
}
[root@localhost regexp]# go run re1.go
true <nil>
2 regexp.MatchReader()
判断在 r 中能否找到正则表达式 pattern 所匹配的子串
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
- pattern：要查找的正则表达式
- r：要在其中进行查找的 RuneReader 接口
- matched：返回是否找到匹配项
- err：返回查找过程中遇到的任何错误
package main
import (
"regexp"
"fmt"
"bytes"
)
func main() {
r := bytes.NewReader([]byte("Hello World!"))
fmt.Println(regexp.MatchReader("H.* ", r))
}
[root@localhost regexp]# go run re2.go
true <nil>
3 regexp.MatchString()
判断在 s 中能否找到正则表达式 pattern 所匹配的子串
func MatchString(pattern string, s string) (matched bool, err error)
- pattern：要查找的正则表达式
- r：要在其中进行查找的字符串
- matched：返回是否找到匹配项
- err：返回查找过程中遇到的任何错误
package main
import (
"regexp"
"fmt"
)
func main() {
fmt.Println(regexp.MatchString("H.* ", "Hello World!"))
}
[root@localhost regexp]# go run re3.go
true <nil>
4 regexp.QuoteMeta
QuoteMeta 将字符串 s 中的“特殊字符”转换为其“转义格式”
特殊字符有：.+*?()|[]{}^$，这些字符用于实现正则语法，所以当作普通字符使用时需要转换
func QuoteMeta(s string) string
package main
import (
"regexp"
"fmt"
)
func main() {
fmt.Println(regexp.QuoteMeta("(?P:Hello) [a-z]"))
}
[root@localhost regexp]# go run re4.go
\(\?P:Hello\) \[a-z\]
5 regexp.Compile()创建 Regexp 对象
Regexp 结构表示一个编译后的正则表达式
Regexp 的公开接口都是通过方法实现的
多个 goroutine 并发使用一个 RegExp 是安全的
type Regexp struct {
// 私有字段
}
Compile 用来解析正则表达式 expr 是否合法，如果合法，则返回一个 Regexp 对象
func Compile(expr string) (*Regexp, error)
package main
import (
"regexp"
"fmt"
)
func main() {
reg, err := regexp.Compile(`\w+`)
fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)
}
[root@localhost regexp]# go run re5.go
"Hello",<nil>
6 regexp.CompilePOSIX()创建regexp对象
CompilePOSIX 的作用和 Compile 一样，不同的是，CompilePOSIX 使用 POSIX 语法，同时，它采用最左最长方式搜索，而 Compile 采用最左最短方式搜索，POSIX 语法不支持 Perl 的语法格式：\d、\D、\s、\S、\w、\W
func CompilePOSIX(expr string) (*Regexp, error)
package main
import (
"regexp"
"fmt"
)
func main() {
reg, err := regexp.CompilePOSIX(`[[:word:]]+`)
fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)
}
[root@localhost regexp]# go run re6.go
"Hello",<nil>
7 regexp.MustCompile创建regexp对象
MustCompile 的作用和 Compile 一样，不同的是，当正则表达式 str 不合法时，MustCompile 会抛出异常，而 Compile 仅返回一个 error 值。
func MustCompile(str string) *Regexp
package main
import (
"regexp"
"fmt"
)
func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello World!"))
}
[root@localhost regexp]# go run re7.go
Hello
regexp.MustCompilePOSIX()创建对象
MustCompilePOSIX 的作用和 CompilePOSIX 一样，不同的是，当正则表达式 str 不合法时，MustCompilePOSIX 会抛出异常，而 CompilePOSIX 仅返回一个 error 值。
func MustCompilePOSIX(str string) *Regexp
package main
import (
"regexp"
"fmt"
)
func main() {
reg := regexp.MustCompilePOSIX(`[[:word:]].+ `)
fmt.Printf("%q\n", reg.FindString("Hello World!"))
}
[root@localhost regexp]# go run re8.go
"Hello "
8 Find()方法
在 byte 中查找 re 中编译好的正则表达式，并返回第一个匹配的内容
func (re *Regexp) Find(b []byte) []byte
package main
import (
"regexp"
"fmt"
)
func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.Find([]byte("Hello World!")))
}
[root@localhost regexp]# go run re9.go
"Hello"
FindString()方法
在 string 中查找 re 中编译好的正则表达式，并返回第一个匹配的内容
func (re *Regexp) FindString(s string) string
package main
import (
"regexp"
"fmt"
)
func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello World!"))
}
[root@localhost regexp]# go run re10.go
Hello
9 FindAll()方法
在 byte 中查找 re 中编译好的正则表达式，并返回所有匹配的内容{{匹配项}, {匹配项}, …}，只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项。
func (re *Regexp) FindAll(b []byte, n int) [][]byte
package main
import (
"regexp"
"fmt"
)
func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.FindAll([]byte("Hello World!"), -1))
}
[root@localhost regexp]# go run re11.go
["Hello" "World"]
10 FindAllString()方法
在 string 中查找 re 中编译好的正则表达式，并返回所有匹配的内容{{匹配项}, {匹配项}, …}，只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项。
func (re *Regexp) FindAllString(s string, n int) []string
package main
import (
"regexp"
"fmt"
)
func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.FindAllString(("Hello World!"), -1))
}
[root@localhost regexp]# go run re12.go
["Hello" "World"]
11 FindIndex()方法
在 b 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置{起始位置, 结束位置}
func (re *Regexp) FindIndex(b []byte) (loc []int)
package main
import (
"regexp"
"fmt"
)
func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.FindIndex([]byte("Hello World!")))
}
[root@localhost regexp]# go run re13.go
['\x00' '\x05']
12 FindStringIndex()方法
在 s 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置{起始位置, 结束位置}
func (re *Regexp) FindStringIndex(s string) (loc []int)
package main
import (
"regexp"
"fmt"
)
func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.FindStringIndex("Hello World!"))
}
[root@localhost regexp]# go run re14.go
['\x00' '\x05']
13 FindReaderIndex()方法
在 r 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置{起始位置, 结束位置}
func (re *Regexp) FindReaderIndex(r io.RuneReader) (loc []int)
package main
import (
"regexp"
"fmt"
"bytes"
)
func main() {
r := bytes.NewReader([]byte("Hello World!"))
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindReaderIndex(r))
}
[root@localhost regexp]# go run re15.go
[0 5]
14 FindAllIndex()方法
在 b 中查找 re 中编译好的正则表达式，并返回所有匹配的位置 {{起始位置, 结束位置}, {起始位置, 结束位置}, …}，只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
package main
import (
"regexp"
"fmt"
)
func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindAllIndex([]byte("Hello World!"), -1))
}
[root@localhost regexp]# go run re16.go
[[0 5] [6 11]]
15 FindAllStringIndex()方法
在 b 中查找 re 中编译好的正则表达式，并返回所有匹配的位置 {{起始位置, 结束位置}, {起始位置, 结束位置}, …},只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项.
func (re *Regexp) FindAllStringIndex(s string, n int) [][]int
package main
import (
"regexp"
"fmt"
)
func main() {
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindAllStringIndex("Hello World!", -1))
}
[root@localhost regexp]# go run re17.go
[[0 5] [6 11]]
