Go Regex(정규 표현식)

Go Regex 패키지는 문자열을 검색하는 데 사용됩니다. 문자열을 검색하려면 문자열 패턴을 제공해야 합니다.

모델을 regex 객체에 컴파일해야 합니다. 그렇게 하면 메서드를 호출할 수 있습니다.

compile()과 mustcompile() 함수를 사용하여 정규 표현식 객체를 검색할 수 있습니다. 지금은 함수를 사용하여 문자열을 찾을 수 있습니다. 예를 들어, FindString(), FindStringSubmatch(), FindStringIndex() 등.

정규 표현식 예제1

예제

package main
import (
	"fmt"
	"regexp"
)
func　main()　{
	re　:=　regexp.MustCompile(".com")
	fmt.Println(re.FindString("oldtoolbag.com"))
	fmt.Println(re.FindString("abc.org"))
	fmt.Println(re.FindString("fb.com"))
{}

출력:

.com
.com

FindString() 메서드는 가장 왼쪽에 일치하는 텍스트를 포함한 문자열을 반환합니다. 일치가 없으면 빈 문자열을 반환합니다.

정규 표현식 예제2

예제

package main
import (
	"fmt"
	"regexp"
)
func　main()　{
	re　:=　regexp.MustCompile(".com")
	fmt.Println(re.FindStringIndex("google.com"))
	fmt.Println(re.FindStringIndex("abc.org"))
	fmt.Println(re.FindStringIndex("fb.com"))
{}

출력:

[6　10]
[]
[2　6]

정규 표현식 예제3

FindStringSubmatch() 메서드를 사용할 수 있습니다. 이 메서드는 가장 왼쪽에 있는 일치와 일치 텍스트를 포함한 문자열 배열을 반환합니다. 일치가 없으면 빈 문자열이 반환됩니다.

예제

package main
import (
	"fmt"
	"regexp"
)
func　main()　{
	re　:=　regexp.MustCompile("f([a-z]+)ing")
	fmt.Println(re.FindStringSubmatch("flying"))
	fmt.Println(re.FindStringSubmatch("abcfloatingxyz"))
{}

출력:

[flying　ly]
[floating　loat]
Process finished with exit code 0

Go 언어 정규 표현식 regexp 패키지에서 자주 사용되는 메서드

Go 언어의 정규 표현식 매칭은 go 언어의 regexp 패키지를 사용할 수 있습니다. 　

Go 언어의 정규 표현식은 다른 언어의 정규 표현식과 규칙이 같지만, 호출하는 함수가 다릅니다. 　　

정규 표현식을 생성할 때 `pattern` 형식을 사용하는 것이 좋습니다.

regexp.Match

//　b에서 정규 표현식 pattern이 일치하는 부분 문자열을 찾을 수 있는지 확인합니다
//　pattern: 검색할 정규 표현식
//　b: 검색을 수행할 것인 []byte
//　matched: 매치가 발견되었는지 여부를 반환합니다
//　err: 검색 과정에서 발생한 모든 오류를 반환합니다
//　이 함수는 Regexp의 메서드를 호출하여 구현됩니다.
func Match(pattern string, b []byte) (matched bool, err error)

온라인 예제

package main
　
import (
　　　　"fmt"
　　　　"regexp"
)
　
func　main()　{
　　　　matched, err := regexp.Match("^abc.*z$", []byte("abcdefgz"))
　　　　fmt.Println(matched, err)　//true　nil
　
　　　　matched, err = regexp.Match("^abc.*z$", []byte("bcdefgz"))
　　　　fmt.Println(matched, err)　//false　nil
{}

regexp.MatchString

//　s에서 정규 표현식 pattern이 일치하는 부분 문자열을 찾을 수 있는지 확인합니다
　//　pattern: 검색할 정규 표현식
　//　r: 검색할 문자열
　//　matched: 매치가 발견되었는지 여부를 반환합니다
　//　err: 검색 과정에서 발생한 모든 오류를 반환합니다
　//　이 함수는 Regexp의 메서드를 호출하여 구현됩니다.
　
　func MatchString(pattern string, s string) (matched bool, err error)

온라인 예제

package main
　
import (
　　　　"fmt"
　　　　"regexp"
)
　
func　main()　{
　　　　matched, err := regexp.MatchString("^abc.*z$", "abcdefgz")
　　　　fmt.Println(matched, err)　//true　<nil>
　
　　　　matched, err = regexp.MatchString("^abc.*z$", "bcdefgz")
　　　　fmt.Println(matched, err)　//false　<nil>
{}

regexp.Compile

//　Compile 메서드는 정규 표현식 expr이 유효한지 확인합니다. 유효하면 Regexp 객체를 반환합니다
//　Regexp 객체는 어떤 텍스트에서든 필요한 작업을 수행할 수 있습니다
func Compile(expr string) (*Regexp, error)

regexp 객체 포인터를 반환하며, 반환 값을 사용하여 regexp에서 정의된 메서드를 호출할 수 있습니다. 예를 들어, Match, MatchString, find 등.

온라인 예제

//func Compile(expr string) (*Regexp, error)
r, _ := regexp.Compile(`f([a-z]+)`)
　
//func　(re　*Regexp) Match(b []byte) bool
fmt.Println(r.Match([]byte("foo")))　//true
　
//func　(re　*Regexp) MatchString(s string) bool
fmt.Println(r.MatchString("foo"))　//true
　
//func　(re　*Regexp) FindString(s string) string
//한 번만 일치
fmt.Println(r.FindString("foo　func"))　//foo
　
//func　(re　*Regexp)　FindStringIndex(s　string)　(loc　[]int)
fmt.Println(r.FindStringIndex("demo　foo　func"))　//[5　8]
　
//func　(re　*Regexp)　FindStringSubmatch(s string)　[]string
//한 번만 매칭하면, 결과에서 인덱스 0의 값은 전체 매칭 문자열의 값이고, 두 번째 값은 서브 표현식의 값입니다
fmt.Println(r.FindStringSubmatch("this　foo　func　fan"))　//[foo　oo]
　
//FindStringSubmatch에서 서브 표현식이 없으면 서브 표현식을 검사하지 않습니다
demo,　_　:=　regexp.Compile(`foo`)
fmt.Println(demo.FindStringSubmatch("foo"))　//[foo]
　
//func　(re　*Regexp.FindStringSubmatchIndex(s string) []int
fmt.Println(r.FindStringSubmatchIndex("foo　func"))　//[0　3　1　3]
　
//func　(re　*Regexp)　FindAllString(s　string,　n　int)　[]string
//n이-1n이 없을 때, 모든 일치하는 문자열을 매칭합니다-1n이 없을 때, n번만 매칭합니다
fmt.Println(r.FindAllString("foo　func　fan",　-1))　//[foo　func　fan]
fmt.Println(r.FindAllString("foo　func　fan",　2))　　//[foo　func]
　
//func　(re　*Regexp.FindAllStringSubmatchIndex(s string, n int) [][]int
//n도 나타내는 것이 매칭 횟수입니다-1모든 것을 나타냅니다
fmt.Println(r.FindAllStringSubmatchIndex("foo　func　demo　fan",　-1))
//[[0　3　1　3]]4　8　5　8]]14　17　15　17]]
　
//대체
　
//func　(re　*Regexp) ReplaceAll(src []byte, repl []byte) []byte
fmt.Println(string(r.ReplaceAll([]byte("this　is　foo,　that　is　func,　they　are　fan"),　[]byte("x"))))
//this　is　x,　that　is　x,　they　are　x
　
//func　(re　*Regexp) ReplaceAllString(src string, repl string) string
fmt.Println(r.ReplaceAllString("this　is　foo,　that　is　func,　they　are　fan",　"xx"))

regexp.MustCompile과上面的regexp.Compile 사용법이 유사합니다.

Go 언어 정규 표현식 regexp 패키지 상세 설명

//　regexp.go 상세 설명
------------------------------------------------------------
1. []byte에서 정규 표현식 pattern이 일치하는 부분 문자열을 찾을 수 있는지�断
//　pattern: 검색할 정규 표현식
//　b: 검색을 수행할 것인 []byte
//　matched: 매치가 발견되었는지 여부를 반환합니다
//　err: 검색 과정에서 발생한 모든 오류를 반환합니다
//　이 함수는 Regexp의 메서드를 호출하여 구현됩니다.
func Match(pattern string, b []byte) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.*　", []byte("Hello World!")))
//　true
{}
------------------------------------------------------------
2. r에서 정규 표현식 pattern이 매치되는 부분 문자열을 찾을 수 있는지 확인합니다.
//　pattern: 검색할 정규 표현식
//　r: 검색할 RuneReader 인터페이스
//　matched: 매치가 발견되었는지 여부를 반환합니다
//　err: 검색 과정에서 발생한 모든 오류를 반환합니다
//　이 함수는 Regexp의 메서드를 호출하여 구현됩니다.
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
func　main()　{
r := bytes.NewReader([]byte("Hello　World!"))
fmt.Println(regexp.MatchReader("H.*　", r))
//　true
{}
------------------------------------------------------------
3. s에서 정규 표현식 pattern이 매치되는 부분 문자열을 찾을 수 있는지 확인합니다.
//　pattern: 검색할 정규 표현식
//　r: 검색할 문자열
//　matched: 매치가 발견되었는지 여부를 반환합니다
//　err: 검색 과정에서 발생한 모든 오류를 반환합니다
//　이 함수는 Regexp의 메서드를 호출하여 구현됩니다.
func MatchString(pattern string, s string) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.*　", "Hello World!"))
//　true
{}
------------------------------------------------------------
4. QuoteMeta는 문자열 s의 '특수 문자'를 '.escape format'으로 변환합니다.
//　예를 들어, QuoteMeta(`[foo]`)은 `
foo
`.
//　특수 문자는: \.+*?()|[]{}^$
//　이 문자들은 정규 표현식 문법을 구현하기 위해 사용되며, 따라서 일반 문자로 사용할 때는 변환되어야 합니다.
func QuoteMeta(s string) string
func　main()　{
fmt.Println(regexp.QuoteMeta("(?P:Hello)　[a-z]"))
//　\?P:Hello
a−z
{}
------------------------------------------------------------
5.Regexp 구조는 컴파일된 정규 표현식을 나타냅니다.
//　Regexp의 공개 인터페이스는 모두 메서드를 통해 구현됩니다.
//　多个 goroutine가 동시에 하나의 RegExp을 사용하는 것은 안전합니다.
type Regexp struct {
//　비공개 필드
{}
//　Complite, CompilePOSIX, MustCompile, MustCompilePOSIX를 통해
//　네 가지 함수를 통해 Regexp 객체를 생성할 수 있습니다.
------------------------------------------------------------
6.Compile 사용하여 정규 표현식 expr이 유효한지 확인합니다. 유효하면 Regexp 객체를 반환합니다.
//　Regexp 객체는 어떤 텍스트에서든 필요한 작업을 수행할 수 있습니다
func Compile(expr string) (*Regexp, error)
func　main()　{
reg, err := regexp.Compile(`\w+`)
fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)
//　"Hello"
{}
------------------------------------------------------------
7.CompilePOSIX의 역할은 Compile과 같습니다
//　다른 점은 CompilePOSIX는 POSIX 문법을 사용합니다
//　그리고, 가장 왼쪽에서 가장 긴 방식으로 검색합니다
//　Compile은 가장 왼쪽에서 가장 짧은 방식으로 검색합니다
//　POSIX 문법은 Perl 문법 형식: \d, \D, \s, \S, \w, \W을 지원하지 않습니다
func CompilePOSIX(expr string) (*Regexp, error)
func　main()　{
reg, err := regexp.CompilePOSIX(`[[:word:]]+`)
fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)
//　"Hello"
{}
------------------------------------------------------------
8.MustCompile의 역할은 Compile과 같습니다
//　다른 점은 정규 표현식 str이 유효하지 않을 때 MustCompile은 예외를 발생시킵니다
//　Compile은 단순히 error 값만 반환합니다
func MustCompile(str string)　*Regexp
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　Hello
{}
------------------------------------------------------------
9.MustCompilePOSIX의 역할은 CompilePOSIX와 같습니다
//　다른 점은 정규 표현식 str이 유효하지 않을 때 MustCompilePOSIX는 예외를 발생시킵니다
//　CompilePOSIX는 단순히 error 값만 반환합니다
func MustCompilePOSIX(str string)　*Regexp
func　main()　{
reg := regexp.MustCompilePOSIX(`[[:word:]].+　`)
fmt.Printf("%q\n", reg.FindString("Hello World!"))
//　"Hello"
{}
------------------------------------------------------------
10. []byte에서 re에서 컴파일된 정규 표현식을 찾아 첫 번째 일치 내용을 반환합니다
func　(re　*Regexp) Find(b []byte) []byte
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.Find([]byte("Hello World!")))
//　"Hello"
{}
------------------------------------------------------------
11. string에서 re에서 컴파일된 정규 표현식을 찾아 첫 번째 일치 내용을 반환합니다
func　(re　*Regexp) FindString(s string) string
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　"Hello"
{}
------------------------------------------------------------
12.[]byte에 re에서 컴파일된 정규 표현식을 찾아 모든 일치 내용을 반환합니다
//　{{일치 항목},　{일치 항목},　...}
//　n이 0보다 작으면, 전체 매치 아이템을 찾습니다.
func　(re　*Regexp)　FindAll(b　[]byte,　n　int)　[][]byte
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q",　reg.FindAll([]byte("Hello　World!"),　-1))
//　["Hello"　"World"]
{}
------------------------------------------------------------
13string에서 re에서 컴파일된 정규 표현식을 찾아 모든 일치 내용을 반환합니다.
//　{일치 항목,　일치 항목,　...}
//　n이 0보다 작으면, 전체 매치 아이템을 찾습니다.
func　(re　*Regexp)　FindAllString(s　string,　n　int)　[]string
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q",　reg.FindAllString("Hello　World!",　-1))
//　["Hello"　"World"]
{}
------------------------------------------------------------
14.　[]byte에 re에서 컴파일된 정규 표현식을 찾아 첫 번째 일치 위치를 반환합니다
//　{시작 위치,　끝 위치}
func　(re　*Regexp)　FindIndex(b　[]byte)　(loc　[]int)
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindIndex([]byte("Hello　World!")))
//　[0　5]
{}
------------------------------------------------------------
15.　string에 re에서 컴파일된 정규 표현식을 찾아 첫 번째 일치 위치를 반환합니다
//　{시작 위치,　끝 위치}
func　(re　*Regexp)　FindStringIndex(s　string)　(loc　[]int)
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindStringIndex("Hello　World!"))
//　[0　5]
{}
------------------------------------------------------------
16. r에서 re에 컴파일된 정규 표현식을 찾아 첫 번째 매치 위치를 반환합니다.
//　{시작 위치,　끝 위치}
func　(re　*Regexp)　FindReaderIndex(r　io.RuneReader)　(loc　[]int)
func　main()　{
r := bytes.NewReader([]byte("Hello　World!"))
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindReaderIndex(r))
//　[0　5]
{}
------------------------------------------------------------
17. []byte에서 re에 컴파일된 정규 표현식을 찾아 모든 매치 위치를 반환합니다.
//　{{시작 위치,　끝 위치},　{시작 위치,　끝 위치},　...}
//　n이 0보다 작으면, 전체 매치 아이템을 찾습니다.
func　(re　*Regexp)　FindAllIndex(b　[]byte,　n　int)　[][]int
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindAllIndex([]byte("Hello　World!"),　-1))
//　[[0　5]]6　11]]
{}
------------------------------------------------------------
18. string에서 re에 컴파일된 정규 표현식을 찾아 모든 매치 위치를 반환합니다.
//　{{시작 위치,　끝 위치},　{시작 위치,　끝 위치},　...}
//　n이 0보다 작으면, 전체 매치 아이템을 찾습니다.
func　(re　*Regexp)　FindAllStringIndex(s　string,　n　int)　[][]int
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindAllStringIndex("Hello　World!",　-1))
//　[[0　5]]6　11]]
{}
------------------------------------------------------------
19[]byte에서 re에서 컴파일된 정규 표현식을 찾아 첫 번째 일치 내용을 반환합니다.
//　동시에 부 표현식 일치 내용을 반환합니다.
//　{{전체 일치 항목},　{부 일치 항목},　{부 일치 항목},　...}
func　(re　*Regexp)　FindSubmatch(b []byte)　[][]byte
func　main()　{
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q",　reg.FindSubmatch([]byte("Hello　World!")))
//　["Hello"　"H"　"o"]
{}
------------------------------------------------------------
20. string에서 re에서 컴파일된 정규 표현식을 찾아 첫 번째 일치 내용을 반환합니다.
//　동시에 부 표현식 일치 내용을 반환합니다.
//　{전체 일치 항목,　부 일치 항목,　부 일치 항목,　...}
func　(re　*Regexp)　FindStringSubmatch(s string)　[]string
func　main()　{
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q",　reg.FindStringSubmatch("Hello　World!"))
//　["Hello"　"H"　"o"]
{}
------------------------------------------------------------
21[]byte에서 re에서 컴파일된 정규 표현식을 찾아 모든 일치 내용을 반환합니다.
//　동시에 부 표현식 일치 내용을 반환합니다.
//　{
//　{{전체 일치 항목},　{부 일치 항목},　{부 일치 항목},　...},
//　{{전체 일치 항목},　{부 일치 항목},　{부 일치 항목},　...},
//　...
//　{}
func　(re　*Regexp)　FindAllSubmatch(b []byte,　n int)　[][][]byte
func　main()　{
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q",　reg.FindAllSubmatch([]byte("Hello　World!"),　-1))
//　[["Hello"　"H"　"o"]　["World"　"W"　"d"]]
{}
------------------------------------------------------------
22string에서 re에서 컴파일된 정규 표현식을 찾아 모든 일치 내용을 반환합니다.
//　동시에 부 표현식 일치 내용을 반환합니다.
//　{
//　{전체 일치 항목,　부 일치 항목,　부 일치 항목,　...},
//　{전체 일치 항목,　부 일치 항목,　부 일치 항목,　...},
//　...
//　{}
//　n이 0보다 작으면, 전체 매치 아이템을 찾습니다.
func　(re　*Regexp)　FindAllStringSubmatch(s string,　n int)　[][]string
func　main()　{
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q",　reg.FindAllStringSubmatch("Hello　World!",　-1))
//　[["Hello"　"H"　"o"]　["World"　"W"　"d"]]
{}
------------------------------------------------------------
23[]byte에서 re에서 컴파일된 정규 표현식을 찾아 첫 번째 일치 위치를 반환합니다.
//　서브 표현식 매치 위치를 함께 반환합니다.
//　{전체 항목 시작, 전체 항목 종료, 서브 항목 시작, 서브 항목 종료, 서브 항목 시작, 서브 항목 종료, ...}
func　(re　*Regexp)　FindSubmatchIndex(b []byte)　[]int
func　main()　{
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindSubmatchIndex([]byte("Hello　World!")))
//　[0　5　0　1　4　5]
{}
------------------------------------------------------------
24string에서 re에서 컴파일된 정규 표현식을 찾아 첫 번째 일치 위치를 반환합니다.
//　서브 표현식 매치 위치를 함께 반환합니다.
//　{전체 항목 시작, 전체 항목 종료, 서브 항목 시작, 서브 항목 종료, 서브 항목 시작, 서브 항목 종료, ...}
func　(re　*Regexp.FindStringSubmatchIndex(s string) []int
func　main()　{
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindStringSubmatchIndex("Hello　World!"))
//　[0　5　0　1　4　5]
{}
------------------------------------------------------------
25. r에서 re에 컴파일된 정규 표현식을 찾아 첫 번째 매치 위치를 반환합니다.
//　서브 표현식 매치 위치를 함께 반환합니다.
//　{전체 항목 시작, 전체 항목 종료, 서브 항목 시작, 서브 항목 종료, 서브 항목 시작, 서브 항목 종료, ...}
func　(re　*Regexp.FindReaderSubmatchIndex(r io.RuneReader) []int
func　main()　{
r := bytes.NewReader([]byte("Hello　World!"))
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindReaderSubmatchIndex(r))
//　[0　5　0　1　4　5]
{}
------------------------------------------------------------
26. []byte에서 re에 컴파일된 정규 표현식을 찾아 모든 매치 위치를 반환합니다.
//　서브 표현식 매치 위치를 함께 반환합니다.
//　{
//　{전체 항목 시작, 전체 항목 종료, 서브 항목 시작, 서브 항목 종료, 서브 항목 시작, 서브 항목 종료, ...},
//　{전체 항목 시작, 전체 항목 종료, 서브 항목 시작, 서브 항목 종료, 서브 항목 시작, 서브 항목 종료, ...},
//　...
//　{}
//　n이 0보다 작으면, 전체 매치 아이템을 찾습니다.
func　(re　*Regexp.FindAllSubmatchIndex(b []byte, n int) [][]int
func　main()　{
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindAllSubmatchIndex([]byte("Hello　World!"),　-1))
//　[[0　5　0　1　4　5]]6　11　6　7　10　11]]
{}
------------------------------------------------------------
27. string에서 re에 컴파일된 정규 표현식을 찾아 모든 매치 위치를 반환합니다.
//　서브 표현식 매치 위치를 함께 반환합니다.
//　{
//　{전체 항목 시작, 전체 항목 종료, 서브 항목 시작, 서브 항목 종료, 서브 항목 시작, 서브 항목 종료, ...},
//　{전체 항목 시작, 전체 항목 종료, 서브 항목 시작, 서브 항목 종료, 서브 항목 시작, 서브 항목 종료, ...},
//　...
//　{}
//　n이 0보다 작으면, 전체 매치 아이템을 찾습니다.
func　(re　*Regexp.FindAllStringSubmatchIndex(s string, n int) [][]int
func　main()　{
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindAllStringSubmatchIndex("Hello　World!",　-1))
//　[[0　5　0　1　4　5]]6　11　6　7　10　11]]
{}
-----------------------------------------------------------
30. template의 내용을 처리한 후, dst의 끝에 추가합니다.
//　template에 "$"가 있어야 합니다.1、$2${name}1}2이러한 "분류 참조 기호"}
//　match는 FindSubmatchIndex 메서드가 반환하는 결과로, 각 그룹의 위치 정보가 저장되어 있습니다.
//　template에 "분류 참조 기호"가 있으면, "match"를 기준으로 합니다.
//　在　src　中取出相应的子串，替换掉　template　中的　$1、$2　等引用符号。
func　(re　*Regexp)　Expand(dst　[]byte,　template　[]byte,　src　[]byte,　match　[]int)　[]byte
func　main()　{
reg　:=　regexp.MustCompile(`(\w+),(\w+)`)
src　:=　[]byte("Golang,World!")　//　源文本
dst　:=　[]byte("Say:　")　//　目标文本
template　:=　[]byte("Hello　$1,　Hello　$2")　//　模板
match　:=　reg.FindSubmatchIndex(src)　//　解析源文本
//　填写模板，并将模板追加到目标文本中
fmt.Printf("%q",　reg.Expand(dst,　template,　src,　match))
//　"Say:　Hello　Golang,　Hello　World"
{}
------------------------------------------------------------
31.功能同　Expand　一样，只不过参数换成了　string　类型
func　(re　*Regexp)　ExpandString(dst　[]byte,　template　string,　src　string,　match　[]int)　[]byte
func　main()　{
reg　:=　regexp.MustCompile(`(\w+),(\w+)`)
src　:=　"Golang,World!"　//　源文本
dst　:=　[]byte("Say:　")　//　目标文本（可写）
template　:=　"Hello　$1,　Hello　$2"　//　模板
match　:=　reg.FindStringSubmatchIndex(src)　//　解析源文本
//　填写模板，并将模板追加到目标文本中
fmt.Printf("%q",　reg.ExpandString(dst,　template,　src,　match))
//　"Say:　Hello　Golang,　Hello　World"
{}
------------------------------------------------------------
32.　LiteralPrefix　返回所有匹配项都共同拥有的前缀（去除可变元素）
//　prefix：共同拥有的前缀
//　complete：如果　prefix　就是正则表达式本身，则返回　true，否则返回　false
func　(re　*Regexp)　LiteralPrefix()　(prefix　string,　complete　bool)
func　main()　{
reg　:=　regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.LiteralPrefix())
//　Hello　false
reg　=　regexp.MustCompile(`Hello`)
fmt.Println(reg.LiteralPrefix())
//　Hello true
{}
------------------------------------------------------------
33切换到“贪婪模式”
func　(re　*Regexp) Longest()
func　main()　{
text := `Hello World,　123　Go!`
pattern := `(?U)H[\w\s]+o`　//　正则标记“非贪婪模式”(?U)
reg := regexp.MustCompile(pattern)
fmt.Printf("%q\n", reg.FindString(text))
//　Hello
reg.Longest()　//　切换到“贪婪模式”
fmt.Printf("%q\n", reg.FindString(text))
//　Hello Wo
{}
------------------------------------------------------------
34判断在 b 中能否找到匹配项
func　(re　*Regexp) Match(b []byte) bool
func　main()　{
b := []byte(`Hello World`)
reg := regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.Match(b))
//　false
reg = regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.Match(b))
//　true
{}
------------------------------------------------------------
35判断在 r 中能否找到匹配项
func　(re　*Regexp) MatchReader(r io.RuneReader) bool
func　main()　{
r := bytes.NewReader([]byte(`Hello World`))
reg := regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.MatchReader(r))
//　false
r.Seek(0, 0)
reg = regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.MatchReader(r))
//　true
{}
------------------------------------------------------------
36判断在 s 中能否找到匹配项
func　(re　*Regexp) MatchString(s string) bool
func　main()　{
s := `Hello World`
reg := regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.MatchString(s))
//　false
reg = regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.MatchString(s))
//　true
{}
------------------------------------------------------------
37统计正则表达式中的分组个数（不包括“非捕获的分组”）
func　(re　*Regexp) NumSubexp() int
func　main()　{
reg := regexp.MustCompile(`(?U)(?:Hello)(\s+)(\w+)`)
fmt.Println(reg.NumSubexp())
//　2
{}
------------------------------------------------------------
38. src에서 일치하는 항목을 검색한 후, repl이 지정한 내용으로 대체합니다
//　모든 것을 대체하고 반환
func　(re　*Regexp) ReplaceAll(src, repl []byte) []byte
func　main()　{
b := []byte("Hello World,　123　Go!")
reg := regexp.MustCompile(`(Hell|G)o`)
rep := []byte("${1}ooo")
fmt.Printf("%q\n", reg.ReplaceAll(b, rep))
//　"Hellooo World,　123　Gooo!"
{}
------------------------------------------------------------
39. src에서 일치하는 항목을 검색한 후, repl이 지정한 내용으로 대체합니다
//　모든 것을 대체하고 반환
func　(re　*Regexp) ReplaceAllString(src, repl string) string
func　main()　{
s := "Hello World,　123　Go!"
reg := regexp.MustCompile(`(Hell|G)o`)
rep := "${1}ooo"
fmt.Printf("%q\n", reg.ReplaceAllString(s, rep))
//　"Hellooo World,　123　Gooo!"
{}
-----------------------------------------------------------
40. src에서 일치하는 항목을 검색한 후, repl이 지정한 내용으로 대체합니다
//　만약 repl에 "그룹 참조 기호"($)가 포함되어 있다면1、$name)에 대해 "그룹 참조 기호"를 일반 문자로 처리
//　모든 것을 대체하고 반환
func　(re　*Regexp) ReplaceAllLiteral(src, repl []byte) []byte
func　main()　{
b := []byte("Hello World,　123　Go!")
reg := regexp.MustCompile(`(Hell|G)o`)
rep := []byte("${1}ooo")
fmt.Printf("%q\n", reg.ReplaceAllLiteral(b, rep))
//　"${1}ooo World,　123　${1}ooo!"
{}
-----------------------------------------------------------
41. src에서 일치하는 항목을 검색한 후, repl이 지정한 내용으로 대체합니다
//　만약 repl에 "그룹 참조 기호"($)가 포함되어 있다면1、$name)에 대해 "그룹 참조 기호"를 일반 문자로 처리
//　모든 것을 대체하고 반환
func　(re　*Regexp) ReplaceAllLiteralString(src, repl string) string
func　main()　{
s := "Hello World,　123　Go!"
reg := regexp.MustCompile(`(Hell|G)o`)
rep := "${1}ooo"
fmt.Printf("%q\n", reg.ReplaceAllLiteralString(s, rep))
//　"${1}ooo World,　123　${1}ooo!"
{}
------------------------------------------------------------
42. src에서 일치하는 항목을 검색한 후, 일치하는 내용을 repl로 처리하여 src의 일치하는 항목을 대체합니다
//　만약 repl의 반환 값에 "그룹 참조 기호"($)가 포함되어 있다면1、$name)에 대해 "그룹 참조 기호"를 일반 문자로 처리
//　모든 것을 대체하고 반환
func　(re　*Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
func　main()　{
s := []byte("Hello World!")
reg　:=　regexp.MustCompile("(H)ello")
rep := []byte("$0$1")
fmt.Printf("%s\n", reg.ReplaceAll(s, rep))
//　
fmt.Printf("%s\n", reg.ReplaceAllFunc(s,
func(b []byte) []byte {
rst := []byte{}
rst = append(rst, b...)
rst = append(rst, "$1"...)
return rst
))
//　Hello$1　World!
{}
k
------------------------------------------------------------
43. src에서 일치하는 항목을 검색한 후, 일치하는 내용을 repl로 처리하여 src의 일치하는 항목을 대체합니다
//　만약 repl의 반환 값에 "그룹 참조 기호"($)가 포함되어 있다면1、$name)에 대해 "그룹 참조 기호"를 일반 문자로 처리
//　모든 것을 대체하고 반환
func　(re　*Regexp)　ReplaceAllStringFunc(src　string,　repl　func(string)　string)　string
func　main()　{
s　:=　"Hello　World!"
reg　:=　regexp.MustCompile("(H)ello")
rep　:=　"$0$"1"
fmt.Printf("%s\n",　reg.ReplaceAllString(s,　rep))
//　
fmt.Printf("%s\n",　reg.ReplaceAllStringFunc(s,
func(b　string)　string　{
return　b　+　"$1"
))
//　Hello$1　World!
{}
------------------------------------------------------------
43.s에서 일치하는 항목을 검색하여 일치하는 항목을 분할 기준으로 s를 여러个子 스트링으로 분할
//　n개의 서브 스트링을 최대로 분할, n번째 서브 스트링은 분할되지 않음
//　n이 -1보다 작으면 모든 서브 스트링을 분할
//　반환된 서브 스트링 목록
func　(re　*Regexp)　Split(s　string,　n　int)　[]string
func　main()　{
s　:=　"Hello　World\tHello\nGolang"

fmt.Printf("%q\n",　reg.Split(s,　-1))
//　["Hello"　"World"　"Hello"　"Golang"]
{}
------------------------------------------------------------
44.반환 re 의 "정규 표현식" 문자열
func　(re　*Regexp)　String()　string
func　main()　{
re　:=　regexp.MustCompile("Hello.*$")
fmt.Printf("%s\n",　re.String())
//　Hello.*$
{}
------------------------------------------------------------
45.반환 re 의 그룹 이름 목록, 이름이 없는 그룹은 공백 문자열을 반환
//　반환 값[0]　은 전체 정규 표현식의 이름
//　반환 값[1]　은 그룹　1　의 이름
//　반환 값[2]　은 그룹　2　의 이름
//　……
func　(re　*Regexp)　SubexpNames()　[]string
func　main()　{
re　:=　regexp.MustCompile("(?PHello)　(World)")
fmt.Printf("%q\n",　re.SubexpNames())
//　''　"Name1"　"
{}